@jaeungkim/gantt-chart 0.3.1 → 1.0.0

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/timeline/hooks/useGanttScrollApi.d.ts

@@ -0,0 +1,62 @@
+import { Dayjs } from 'dayjs';
+import { RefObject } from 'react';
+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) */
+    smooth?: boolean;
+    /** Where the target lands inside the viewport (default 'center') */
+    align?: "start" | "center";
+}
+/** A date pinned at a fixed distance from the timeline's visible left edge */
+export interface GanttZoomAnchor {
+    date: Dayjs;
+    /** px from the left edge of the timeline area (the task list pane excluded) */
+    viewportX: number;
+}
+/** Imperative scroll and zoom API */
+export interface GanttScrollApi {
+    /** Scroll horizontally to a given date */
+    scrollToDate: (date: string | Date | Dayjs, options?: GanttScrollOptions) => void;
+    /** Scroll horizontally to today */
+    scrollToToday: (options?: GanttScrollOptions) => void;
+    /** Scroll horizontally and vertically to a given task */
+    scrollToTask: (taskId: string, options?: GanttScrollOptions) => void;
+    /** 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, GanttDetailApi, GanttTaskCreateApi {
+}
+interface UseGanttScrollApiParams {
+    scrollRef: RefObject<HTMLDivElement | null>;
+    bottomRowCells: GanttBottomRowCell[];
+    transformedTasks: TaskTransformed[];
+    selectedScale: GanttScaleKey;
+    rowHeight: number;
+    /** 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;
+}
+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,77 +1,92 @@
 {
   "name": "@jaeungkim/gantt-chart",
-  "version": "0.3.1",
+  "version": "1.0.0",
   "private": false,
   "type": "module",
-  "main": "dist/index.cjs.js",
-  "module": "dist/index.es.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.es.js",
-      "require": "./dist/index.cjs.js"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     },
-    "./style.css": "./dist/gantt-chart.css"
+    "./style.css": "./dist/gantt-chart.css",
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",
     "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",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jaeungkim/gantt-chart.git"
+    "url": "git+https://github.com/jaeungkim/gantt-chart.git"
   },
-  "homepage": "https://github.com/jaeungkim/gantt-chart#readme",
+  "homepage": "https://gantt.jaeungkim.com",
   "bugs": {
     "url": "https://github.com/jaeungkim/gantt-chart/issues"
   },
   "scripts": {
-    "dev": "vite",
-    "build": "vite build",
-    "preview": "vite preview",
-    "lint": "eslint \"src/**/*.{js,jsx,ts,tsx}\"",
-    "lint:fix": "eslint --fix \"src/**/*.{js,jsx,ts,tsx}\"",
-    "type-check": "tsc --noEmit"
+    "dev": "pnpm --filter @gantt-chart/site dev",
+    "build": "vite build && node -e \"require('fs').copyFileSync('dist/index.d.ts','dist/index.d.cts')\"",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "type-check": "tsc --noEmit",
+    "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.13.6",
-    "dayjs": "^1.11.13",
-    "zustand": "^5.0.3"
+    "dayjs": "^1.11.23",
+    "zustand": "^5.0.15"
   },
   "devDependencies": {
-    "@eslint/js": "^9.21.0",
-    "@types/node": "^22.13.7",
-    "@types/react": "^19.0.10",
-    "@types/react-dom": "^19.0.4",
-    "@vitejs/plugin-react": "^4.3.4",
-    "eslint": "^9.21.0",
+    "@eslint/js": "^9.39.5",
+    "@types/node": "^22.20.1",
+    "@types/react": "^19.2.18",
+    "@vitejs/plugin-react": "^4.7.0",
+    "eslint": "^9.39.5",
     "eslint-plugin-react": "^7.37.5",
-    "eslint-plugin-react-hooks": "^5.1.0",
-    "eslint-plugin-react-refresh": "^0.4.19",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "eslint-plugin-react-refresh": "^0.5.5",
     "globals": "^15.15.0",
-    "react": "^19.1.1",
-    "react-dom": "^19.1.1",
-    "typescript": "~5.7.2",
-    "typescript-eslint": "^8.24.1",
-    "vite": "^6.2.3",
-    "vite-plugin-dts": "^4.5.4",
-    "vite-plugin-svgr": "^4.3.0",
-    "vite-tsconfig-paths": "^5.1.4"
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "typescript": "~5.7.3",
+    "typescript-eslint": "^8.69.0",
+    "vite": "^6.4.3",
+    "vite-plugin-dts": "^5.1.0",
+    "vite-tsconfig-paths": "^6.1.1",
+    "vitest": "^4.1.11"
   },
-  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
+  "packageManager": "pnpm@10.30.3",
+  "pnpm": {
+    "overrides": {
+      "@rushstack/node-core-library>ajv": ">=8.18.0",
+      "@microsoft/api-extractor>lodash": ">=4.18.0",
+      "@microsoft/api-extractor>minimatch": ">=10.2.3"
+    }
+  }
 }