@jaeungkim/gantt-chart 0.4.0 → 1.0.0

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;

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

@@ -0,0 +1,11 @@
+export declare const TOUCH_LONG_PRESS_MS = 400;
+export declare const TOUCH_SLOP_PX = 10;
+interface PointerGestureStart {
+    pointerType: string;
+    pointerId: number;
+    clientX: number;
+    clientY: number;
+}
+export declare function armPointerGesture(start: PointerGestureStart, onStart: (clientX: number, clientY: number) => void, target?: EventTarget): (() => void) | null;
+export declare function suppressTouchScroll(): () => void;
+export {};

package/dist/shared/virtual/axis.d.ts

@@ -0,0 +1,13 @@
+export interface VirtualAxis {
+    count: number;
+    /** Size of the whole axis (px) */
+    total: number;
+    sizeAt: (index: number) => number;
+    /** Pixels before `index` starts */
+    offsetAt: (index: number) => number;
+    /** Index of the item covering `px`, clamped to the axis */
+    indexAt: (px: number) => number;
+}
+export declare function fixedAxis(count: number, size: number): VirtualAxis;
+export declare function variableAxis(count: number, sizeAt: (index: number) => number): VirtualAxis;
+export declare function axisOf(count: number, size: number | ArrayLike<number>, fallback?: number): VirtualAxis;

package/dist/shared/virtual/useVirtualWindow.d.ts

@@ -0,0 +1,16 @@
+import { RefObject } from 'react';
+import { VirtualAxis } from './axis';
+import { VirtualWindow } from './window';
+export type ScrollAlign = 'start' | 'center' | 'end' | 'auto';
+interface UseVirtualWindowParams {
+    scrollRef: RefObject<HTMLElement | null>;
+    row: VirtualAxis;
+    col: VirtualAxis;
+}
+interface VirtualWindows {
+    row: VirtualWindow;
+    col: VirtualWindow;
+    scrollToRow: (index: number, align?: ScrollAlign) => void;
+}
+export declare function useVirtualWindow({ scrollRef, row, col, }: UseVirtualWindowParams): VirtualWindows;
+export {};

package/dist/shared/virtual/window.d.ts

@@ -0,0 +1,30 @@
+import { VirtualAxis } from './axis';
+export declare const MIN_VIRTUAL_COUNT = 24;
+export interface VirtualWindow {
+    /** First index to render */
+    start: number;
+    /** Last index to render, inclusive - `-1` when the axis is empty */
+    end: number;
+    /** Pixels before `start` */
+    padStart: number;
+    /** Pixels after `end` */
+    padEnd: number;
+    /** False when the whole axis is being rendered */
+    virtualized: boolean;
+}
+export interface VirtualItem {
+    index: number;
+    key: number;
+    start: number;
+    end: number;
+    size: number;
+}
+export type ScrollDirection = -1 | 0 | 1;
+export declare function fullWindow(count: number): VirtualWindow;
+export declare function windowOf(axis: VirtualAxis, scroll: number, viewport: number, overscan?: number, direction?: ScrollDirection): VirtualWindow;
+export declare function virtualItemsOf(axis: VirtualAxis, window: VirtualWindow): VirtualItem[];
+export declare function windowBounds(axis: VirtualAxis, window: VirtualWindow): {
+    startPx: number;
+    endPx: number;
+};
+export declare function sameWindow(a: VirtualWindow, b: VirtualWindow): boolean;

package/dist/task-list/components/GanttGridSplitter.d.ts

@@ -0,0 +1,6 @@
+interface GanttGridSplitterProps {
+    width: number;
+    onWidthChange: (width: number) => void;
+}
+export default function GanttGridSplitter({ width, onWidthChange, }: GanttGridSplitterProps): import("react").JSX.Element;
+export {};

package/dist/task-list/components/GanttTaskAddRow.d.ts

@@ -0,0 +1,7 @@
+interface GanttTaskAddRowProps {
+    width: number;
+    /** Proposes the new task - the same thing `addTask()` on the chart ref calls */
+    onAdd: () => void;
+}
+export default function GanttTaskAddRow({ width, onAdd, }: GanttTaskAddRowProps): import("react").JSX.Element;
+export {};

package/dist/task-list/components/GanttTaskGrid.d.ts

@@ -0,0 +1,24 @@
+import { VirtualItem } from '../../shared/virtual/window';
+import { GanttTaskMoveApi } from '../hooks/useGanttTaskMove';
+import { GanttInteractionConfig, TaskTransformed } from '../../shared/task';
+import { GanttFocus } from '../../interaction/utils/a11y';
+import { GanttRow } from '../../rows/utils/rows';
+interface GanttTaskGridProps {
+    rows: GanttRow[];
+    virtualItems: VirtualItem[];
+    totalHeight: number;
+    width: number;
+    showRowNumbers: boolean;
+    hierarchy: boolean;
+    collapsedIds: ReadonlySet<string>;
+    onToggleCollapse: (rowId: string) => void;
+    focus: GanttFocus;
+    reorderEnabled: boolean;
+    interaction: GanttInteractionConfig;
+    move: GanttTaskMoveApi;
+    selectedTaskId?: string | null;
+    onRowClick?: (task: TaskTransformed, event: React.MouseEvent) => void;
+    onRowDoubleClick?: (task: TaskTransformed, event: React.MouseEvent) => void;
+}
+export default function GanttTaskGrid({ rows, virtualItems, totalHeight, width, showRowNumbers, hierarchy, collapsedIds, onToggleCollapse, focus, reorderEnabled, interaction, move, selectedTaskId, onRowClick, onRowDoubleClick, }: GanttTaskGridProps): import("react").JSX.Element;
+export {};

package/dist/task-list/hooks/useGanttRowDrag.d.ts

@@ -0,0 +1,17 @@
+import { VirtualItem } from '../../shared/virtual/window';
+import { RefObject } from 'react';
+import { GanttTaskMoveApi } from './useGanttTaskMove';
+import { GanttReorderDraft } from '../../shared/store';
+import { GanttRow } from '../../rows/utils/rows';
+interface UseGanttRowDragParams {
+    rows: GanttRow[];
+    virtualItems: VirtualItem[];
+    bodyRef: RefObject<HTMLDivElement | null>;
+    hierarchy: boolean;
+    move: GanttTaskMoveApi;
+}
+export declare function useGanttRowDrag({ rows, virtualItems, bodyRef, hierarchy, move, }: UseGanttRowDragParams): {
+    onGripPointerDown: (rowIndex: number, event: React.PointerEvent) => void;
+    draft: GanttReorderDraft | null;
+};
+export {};

package/dist/task-list/hooks/useGanttTaskListPane.d.ts

@@ -0,0 +1,11 @@
+interface UseGanttTaskListPaneParams {
+    showTaskList?: boolean;
+}
+interface GanttTaskListPane {
+    width: number;
+    setWidth: (width: number) => void;
+    visible: boolean;
+    inset: number;
+}
+export declare function useGanttTaskListPane({ showTaskList, }: UseGanttTaskListPaneParams): GanttTaskListPane;
+export {};

package/dist/task-list/hooks/useGanttTaskMove.d.ts

@@ -0,0 +1,16 @@
+import { GanttMoveRejection, GanttTaskMove, GanttTaskMoveChange } from '../../core/reorder';
+import { GanttInteractionConfig, Task } from '../../shared/task';
+interface UseGanttTaskMoveParams {
+    hierarchy: boolean;
+    interaction: GanttInteractionConfig;
+    collapsedIds: ReadonlySet<string>;
+    onTasksChange?: (tasks: Task[]) => void;
+    onTaskMove?: (change: GanttTaskMoveChange) => boolean | void;
+    onExpand?: (rowId: string) => void;
+}
+export interface GanttTaskMoveApi {
+    validate: (move: GanttTaskMove) => GanttMoveRejection | null;
+    apply: (move: GanttTaskMove) => boolean;
+}
+export declare function useGanttTaskMove({ hierarchy, interaction, collapsedIds, onTasksChange, onTaskMove, onExpand, }: UseGanttTaskMoveParams): GanttTaskMoveApi;
+export {};

package/dist/timeline/components/GanttChartHeader.d.ts

@@ -0,0 +1,10 @@
+import { GanttBottomRowCell, GanttScaleKey } from '../../shared/types';
+import { GanttVirtualization } from '../hooks/useGanttVirtualization';
+interface GanttChartHeaderProps {
+    bottomRowCells: GanttBottomRowCell[];
+    selectedScale: GanttScaleKey;
+    width: number;
+    virtual: GanttVirtualization;
+}
+declare function GanttChartHeader({ bottomRowCells, selectedScale, width, virtual, }: GanttChartHeaderProps): import("react").JSX.Element;
+export default GanttChartHeader;

package/dist/timeline/components/GanttHolidayLabels.d.ts

@@ -0,0 +1,6 @@
+import { NonWorkingRange } from '../utils/geometry';
+interface GanttHolidayLabelsProps {
+    ranges: NonWorkingRange[];
+}
+export default function GanttHolidayLabels({ ranges, }: GanttHolidayLabelsProps): import("react").JSX.Element | null;
+export {};

package/dist/timeline/components/GanttNonWorkingLayer.d.ts

@@ -0,0 +1,6 @@
+import { NonWorkingRange } from '../utils/geometry';
+interface GanttNonWorkingLayerProps {
+    ranges: NonWorkingRange[];
+}
+export default function GanttNonWorkingLayer({ ranges, }: GanttNonWorkingLayerProps): import("react").JSX.Element | null;
+export {};

package/dist/timeline/components/GanttTodayLine.d.ts

@@ -0,0 +1,6 @@
+export declare function GanttTodayLine({ leftPx }: {
+    leftPx: number | null;
+}): import("react").JSX.Element | null;
+export declare function GanttTodayDot({ leftPx }: {
+    leftPx: number | null;
+}): import("react").JSX.Element | null;

package/dist/{hooks → timeline/hooks}/useGanttScrollApi.d.ts

@@ -1,9 +1,7 @@
 import { Dayjs } from 'dayjs';
 import { RefObject } from 'react';
-import { GanttExportApi } from './useGanttExportApi';
-import { GanttHistoryApi } from './useGanttHistoryApi';
-import { GanttBottomRowCell, GanttScaleKey } from '../types/gantt';
-import { TaskTransformed } from '../types/task';
+import { GanttBottomRowCell, GanttScaleKey } from '../../shared/types';
+import { TaskTransformed } from '../../shared/task';
 /** Options for the scrollTo* methods */
 export interface GanttScrollOptions {
     /** Whether to animate the scroll (default true) */
@@ -25,17 +23,27 @@ export interface GanttScrollApi {
     scrollToToday: (options?: GanttScrollOptions) => void;
     /** Scroll horizontally and vertically to a given task */
     scrollToTask: (taskId: string, options?: GanttScrollOptions) => void;
-    /**
-     * Switch to the finest scale at which the whole project fits the viewport width
-     *
-     * Also scrolls the project into view. Does nothing while there are no tasks.
-     */
+    /** Switches the scale, keeping the centre date centred; an unknown key is ignored */
+    setScale: (scale: GanttScaleKey) => void;
+    /** Switches to the finest scale the whole project fits at and scrolls it into view (no-op with no tasks) */
     zoomToFit: () => void;
     /** The scroll container DOM node (null when unavailable) */
     getScrollElement: () => HTMLDivElement | null;
 }
+/** Opening and closing the detail panel from outside the chart */
+export interface GanttDetailApi {
+    /** Opens the detail panel on a task; unknown ids and a panel-less chart (no `renderDetail`/`showDetail`) are ignored */
+    openDetail: (taskId: string) => void;
+    /** Closes the detail panel */
+    closeDetail: () => void;
+}
+/** Proposing a new task from outside the chart */
+export interface GanttTaskCreateApi {
+    /** Sends a one-tick draft at today to `onTaskCreate`, as the "Add task" button does; no-op without `onTaskCreate` or with `allowTaskCreate` false */
+    addTask: () => void;
+}
 /** Imperative API exposed through the ref */
-export interface GanttHandle extends GanttScrollApi, GanttExportApi, GanttHistoryApi {
+export interface GanttHandle extends GanttScrollApi, GanttDetailApi, GanttTaskCreateApi {
 }
 interface UseGanttScrollApiParams {
     scrollRef: RefObject<HTMLDivElement | null>;
@@ -43,21 +51,12 @@ interface UseGanttScrollApiParams {
     transformedTasks: TaskTransformed[];
     selectedScale: GanttScaleKey;
     rowHeight: number;
-    /**
-     * How much width the pinned task list on the left covers (default 0)
-     *
-     * The timeline starts that far to the right, so centering has to measure against the
-     * narrowed viewport or the target lands behind the pane.
-     */
+    /** Width of the pinned task list (default 0) - centering measures against the narrowed viewport */
     viewportInsetPx?: number;
     /** Switches scale while keeping the anchor date where it is on screen */
     zoomTo: (scale: GanttScaleKey, anchor: GanttZoomAnchor) => void;
+    /** Sets the scale with no anchor - the fallback when there is nothing on screen to pin */
+    setSelectedScale: (scale: GanttScaleKey) => void;
 }
-/**
- * Imperative scroll API
- *
- * Dates outside the timeline and unknown task ids are ignored silently - so that
- * the common case of calling while data is still loading does not throw.
- */
-export declare function useGanttScrollApi({ scrollRef, bottomRowCells, transformedTasks, selectedScale, rowHeight, viewportInsetPx, zoomTo, }: UseGanttScrollApiParams): GanttScrollApi;
+export declare function useGanttScrollApi({ scrollRef, bottomRowCells, transformedTasks, selectedScale, rowHeight, viewportInsetPx, zoomTo, setSelectedScale, }: UseGanttScrollApiParams): GanttScrollApi;
 export {};

package/dist/timeline/hooks/useGanttViewport.d.ts

@@ -0,0 +1,47 @@
+import { RefObject } from 'react';
+import { GanttScrollApi, GanttZoomAnchor } from './useGanttScrollApi';
+import { GanttBottomRowCell, GanttDateRange, GanttRangeExtension, GanttScaleKey, GanttVisibleRange } from '../../shared/types';
+import { Task } from '../../shared/task';
+interface UseGanttRangeExtensionParams {
+    /** Off (the default `infiniteScroll`), the timeline never grows past its tasks */
+    enabled: boolean;
+    scrollRef: RefObject<HTMLDivElement | null>;
+    selectedScale: GanttScaleKey;
+    bottomRowCells: GanttBottomRowCell[];
+    totalWidth: number;
+    /** Width of the pinned task list, which the viewport does not extend into */
+    viewportInsetPx: number;
+    /** A pinned end is where the host put it - growing past it would be undone on every recompute */
+    pinnedStart: boolean;
+    pinnedEnd: boolean;
+}
+export declare function useGanttRangeExtension({ enabled, scrollRef, selectedScale, bottomRowCells, totalWidth, viewportInsetPx, pinnedStart, pinnedEnd, }: UseGanttRangeExtensionParams): GanttRangeExtension;
+interface UseGanttTimelineSyncParams {
+    rawTasks: Task[];
+    selectedScale: GanttScaleKey;
+    /** Pinned window, or undefined to fit the timeline to the tasks */
+    visibleRange: GanttVisibleRange | undefined;
+    hierarchy: boolean;
+    extension: GanttRangeExtension;
+    scrollRef: RefObject<HTMLDivElement | null>;
+    bottomRowCells: GanttBottomRowCell[];
+}
+export declare function useGanttTimelineSync({ rawTasks, selectedScale, visibleRange, hierarchy, extension, scrollRef, bottomRowCells, }: UseGanttTimelineSyncParams): (scale: GanttScaleKey, anchor: GanttZoomAnchor) => void;
+interface UseGanttWheelZoomParams {
+    /** Off (the default `zoomOnWheel`), ctrl/cmd + wheel is left to the browser */
+    enabled: boolean;
+    scrollRef: RefObject<HTMLDivElement | null>;
+    selectedScale: GanttScaleKey;
+    bottomRowCells: GanttBottomRowCell[];
+    /** Width of the pinned task list, which the timeline's own left edge starts after */
+    viewportInsetPx: number;
+    zoomTo: (scale: GanttScaleKey, anchor: GanttZoomAnchor) => void;
+}
+/** Ctrl/Cmd + wheel steps through the scale ladder, keeping the date under the cursor */
+export declare function useGanttWheelZoom({ enabled, scrollRef, selectedScale, bottomRowCells, viewportInsetPx, zoomTo, }: UseGanttWheelZoomParams): void;
+export declare function useGanttScaleReport(selectedScale: GanttScaleKey, onScaleChange?: (scale: GanttScaleKey) => void): void;
+/** Reports the rendered timeline range - the hook a host lazy-loads tasks from */
+export declare function useGanttRangeReport(bottomRowCells: GanttBottomRowCell[], selectedScale: GanttScaleKey, onRangeChange?: (range: GanttDateRange) => void): void;
+/** Scrolls to `initialScrollTo` once, when the timeline first becomes ready */
+export declare function useGanttInitialScroll(initialScrollTo: "today" | string | undefined, bottomRowCells: GanttBottomRowCell[], scrollApi: GanttScrollApi): void;
+export {};

package/dist/timeline/hooks/useGanttVirtualization.d.ts

@@ -0,0 +1,28 @@
+import { RefObject } from 'react';
+import { GanttBottomRowCell } from '../../shared/types';
+import { ScrollAlign } from '../../shared/virtual/useVirtualWindow';
+import { VirtualItem } from '../../shared/virtual/window';
+interface UseGanttVirtualizationParams {
+    /** Number of rows on screen - not the task count, since a lane can share one row */
+    rowCount: number;
+    bottomRowCells: GanttBottomRowCell[];
+    scrollRef: RefObject<HTMLDivElement | null>;
+}
+export interface GanttVirtualization {
+    /** Rows to render, already positioned */
+    virtualRows: VirtualItem[];
+    /** Height of all rows, culled ones included - the scrollable content height */
+    totalHeight: number;
+    /** Time cells to render, already positioned */
+    virtualCells: VirtualItem[];
+    /** Width of the cells skipped before the first rendered one (px) */
+    leadingCellPx: number;
+    /** Vertical bounds of the row window (px) - what the arrows cull against */
+    rowStartPx: number;
+    rowEndPx: number;
+    /** Horizontal culling, shared by the header, the bars and the arrows */
+    isBarVisible: (barLeft: number, barWidth: number) => boolean;
+    scrollToRow: (index: number, align?: ScrollAlign) => void;
+}
+export declare function useGanttVirtualization({ rowCount, bottomRowCells, scrollRef, }: UseGanttVirtualizationParams): GanttVirtualization;
+export {};

package/dist/timeline/utils/geometry.d.ts

@@ -0,0 +1,52 @@
+import { Dayjs } from 'dayjs';
+import { GanttBottomRowCell, GanttDateRange, GanttDragBounds, GanttDragMode, GanttLocaleOptions, GanttRangeExtension, GanttScaleKey, GanttTopHeaderGroup, GanttVisibleRange } from '../../shared/types';
+import { Task, TaskTransformed } from '../../shared/task';
+interface TimelineData {
+    bottomCells: GanttBottomRowCell[];
+    transformedTasks: TaskTransformed[];
+}
+/** The identity of a day that is off with nothing else said about it - no name, no colour. */
+export declare const OFF_DAY_KEY = "off";
+/** What one non-working day is, as far as the shading is concerned. */
+export interface NonWorkingDay {
+    /** Adjacent days merge only when this matches - a named holiday must not fuse with a Saturday */
+    key: string;
+    label?: string;
+    color?: string;
+}
+export interface NonWorkingRange {
+    left: number;
+    width: number;
+    label?: string;
+    color?: string;
+}
+export declare function originShiftPx(prevTicks: GanttBottomRowCell[], nextTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey): number;
+export declare function computeNonWorkingRanges(timelineTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey, nonWorkingDayAt: (date: Dayjs) => NonWorkingDay | null): NonWorkingRange[];
+export declare function shiftByDragSteps(date: Dayjs, steps: number, scaleKey: GanttScaleKey): Dayjs;
+export declare function pxBetweenDates(from: Dayjs, to: Dayjs, scaleKey: GanttScaleKey): number;
+export declare function clampDragDates(mode: GanttDragMode, startDate: Dayjs, endDate: Dayjs, bounds: GanttDragBounds, scaleKey: GanttScaleKey): {
+    startDate: Dayjs;
+    endDate: Dayjs;
+};
+export declare function clampMoveDelta(members: {
+    start: Dayjs;
+    end: Dayjs;
+    bounds: GanttDragBounds;
+}[], requestedMs: number, scaleKey: GanttScaleKey): number;
+export declare function calculateDateOffsets(startDate: Dayjs, endDate: Dayjs, timelineTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey): {
+    barMarginLeftAmount: number;
+    barWidthSize: number;
+};
+export declare function calculateDateOffsetPx(date: Dayjs, timelineTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey): number | null;
+export declare function dateAtOffsetPx(offsetPx: number, timelineTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey): Dayjs | null;
+export declare function timelineRange(timelineTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey): GanttDateRange | null;
+interface DrawnRange {
+    startDate: Dayjs;
+    endDate: Dayjs;
+    leftPx: number;
+    widthPx: number;
+}
+export declare function snapDrawnRange(startPx: number, endPx: number, timelineTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey): DrawnRange | null;
+export declare function createTopHeaderGroups(bottomCells: GanttBottomRowCell[], selectedScale: GanttScaleKey, localeOptions?: GanttLocaleOptions): GanttTopHeaderGroup[];
+export declare function computeTimelineData(rawTasks: Task[], selectedScale: GanttScaleKey, visibleRange?: GanttVisibleRange, hierarchy?: boolean, extension?: GanttRangeExtension): TimelineData;
+export {};

package/dist/timeline/utils/header.d.ts

@@ -0,0 +1,8 @@
+import { GanttBottomRowCell, GanttTopHeaderGroup } from '../../shared/types';
+export declare function mergeHeaderGroups(groups: GanttTopHeaderGroup[]): GanttTopHeaderGroup[];
+export declare function tickBoundaries(cells: GanttBottomRowCell[]): number[];
+export declare function tickCellAt(boundaries: number[], x: number): {
+    index: number;
+    left: number;
+    width: number;
+} | null;

package/dist/timeline/utils/transform.d.ts

@@ -0,0 +1,4 @@
+import { GanttBottomRowCell, GanttScaleKey } from '../../shared/types';
+import { Task, TaskTransformed } from '../../shared/task';
+import { TaskTree } from '../../core/tree';
+export declare function transformTasks(tasks: Task[], timelineTicks: GanttBottomRowCell[], selectedScale: GanttScaleKey, tree?: TaskTree): TaskTransformed[];

package/dist/timeline/utils/viewport.d.ts

@@ -0,0 +1,31 @@
+import { GanttRangeExtension, GanttScaleKey } from '../../shared/types';
+export declare const SCALE_LADDER: GanttScaleKey[];
+export declare function pxPerMs(scale: GanttScaleKey): number;
+export declare function stepScale(scale: GanttScaleKey, direction: number): GanttScaleKey;
+export declare function fitScale(durationMs: number, viewportPx: number): GanttScaleKey;
+interface ZoomAccumulator {
+    delta: number;
+    lastEventAt: number;
+    locked: boolean;
+}
+export declare const INITIAL_ZOOM_ACCUMULATOR: ZoomAccumulator;
+export declare function accumulateZoom(state: ZoomAccumulator, deltaY: number, now: number): {
+    state: ZoomAccumulator;
+    step: number;
+};
+export declare function edgeScrollVelocity(clientX: number, left: number, right: number): number;
+export declare const NO_RANGE_EXTENSION: GanttRangeExtension;
+export declare const MAX_RANGE_EXTENSION_TICKS = 2000;
+interface ExtendRangeParams {
+    current: GanttRangeExtension;
+    scrollLeft: number;
+    viewportPx: number;
+    totalPx: number;
+    pxPerTick: number;
+    canExtend?: {
+        before: boolean;
+        after: boolean;
+    };
+}
+export declare function extendRangeForScroll({ current, scrollLeft, viewportPx, totalPx, pxPerTick, canExtend, }: ExtendRangeParams): GanttRangeExtension | null;
+export {};

package/dist/useGanttSelectors.d.ts

@@ -0,0 +1,11 @@
+export declare function useGanttSelectors(): {
+    rawTasks: import('.').Task[];
+    transformedTasks: import('.').TaskTransformed[];
+    bottomRowCells: import('./shared/types').GanttBottomRowCell[];
+    selectedScale: import('.').GanttScaleKey;
+    selectedTaskId: string | null;
+    syncTasksFromProps: (rawTasks: import('.').Task[]) => void;
+    setSelectedScale: (scale: import('.').GanttScaleKey) => void;
+    setLocaleOptions: (options: import('./shared/types').GanttLocaleOptions | undefined) => void;
+    getTotalWidth: () => number;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaeungkim/gantt-chart",
-  "version": "0.4.0",
+  "version": "1.0.0",
   "private": false,
   "type": "module",
   "main": "./dist/index.cjs",
@@ -25,12 +25,15 @@
     "README.md",
     "LICENSE"
   ],
-  "description": "Lightweight React Gantt Chart component",
+  "description": "React Gantt chart with editable bars, dependency arrows, and headless date utilities",
   "keywords": [
     "gantt",
+    "gantt-chart",
     "chart",
+    "project-management",
     "react",
-    "timeline"
+    "timeline",
+    "virtualized"
   ],
   "author": "jaeungkim",
   "license": "MIT",
@@ -38,25 +41,24 @@
     "type": "git",
     "url": "git+https://github.com/jaeungkim/gantt-chart.git"
   },
-  "homepage": "https://jaeungkim.com/gantt-chart",
+  "homepage": "https://gantt.jaeungkim.com",
   "bugs": {
     "url": "https://github.com/jaeungkim/gantt-chart/issues"
   },
   "scripts": {
-    "dev": "vite",
+    "dev": "pnpm --filter @gantt-chart/site dev",
     "build": "vite build && node -e \"require('fs').copyFileSync('dist/index.d.ts','dist/index.d.cts')\"",
-    "preview": "vite preview",
-    "lint": "eslint \"src/**/*.{js,jsx,ts,tsx}\"",
-    "lint:fix": "eslint --fix \"src/**/*.{js,jsx,ts,tsx}\"",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
     "type-check": "tsc --noEmit",
-    "test": "vitest run"
+    "test": "vitest run",
+    "docs:build": "pnpm build && pnpm --filter @gantt-chart/site build"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0"
   },
   "dependencies": {
-    "@tanstack/react-virtual": "^3.14.10",
     "dayjs": "^1.11.23",
     "zustand": "^5.0.15"
   },
@@ -64,9 +66,7 @@
     "@eslint/js": "^9.39.5",
     "@types/node": "^22.20.1",
     "@types/react": "^19.2.18",
-    "@types/react-dom": "^19.2.5",
     "@vitejs/plugin-react": "^4.7.0",
-    "agentation": "^3.0.2",
     "eslint": "^9.39.5",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^7.1.1",

package/dist/components/GanttBar.d.ts

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

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

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

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

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