@jaeungkim/gantt-chart 0.3.0 → 0.4.0

package/dist/types/gantt.d.ts

@@ -0,0 +1,283 @@
+import { Dayjs } from 'dayjs';
+import { CSSProperties, MouseEvent as ReactMouseEvent, MouseEventHandler, PointerEventHandler, ReactNode } from 'react';
+import { SchedulingPolicy, WorkingCalendar } from 'core';
+import { Task, TaskTransformed } from './task';
+/**
+ * What the drag handlers need to reschedule successors.
+ * Assembled once in Gantt and handed down, so the engine's configuration reaches the
+ * drag hook without every component in between knowing about it.
+ */
+export interface GanttScheduling {
+    policy: SchedulingPolicy;
+    calendar: WorkingCalendar;
+    hierarchy: boolean;
+    onCycle?: (taskIds: string[]) => void;
+}
+/** Theme type - 'light', 'dark', or 'system' (follows the OS setting) */
+export type GanttTheme = 'light' | 'dark' | 'system';
+export type GanttScaleKey = 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
+/** Unit the top header row groups by ('quarter' has no dayjs equivalent - see core/dates) */
+export type GanttLabelUnit = 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
+/** What a bar drag is doing - moving the whole bar, or resizing one edge */
+export type GanttDragMode = 'bar' | 'left' | 'right';
+/** Window a bar may be dragged within - either end may be left open */
+export interface GanttDragBounds {
+    min?: Dayjs;
+    max?: Dayjs;
+}
+/** Fixed timeline window, replacing the auto-fit to the task dates */
+export interface GanttVisibleRange {
+    start?: Dayjs;
+    end?: Dayjs;
+}
+export interface GanttScaleConfig {
+    labelUnit: GanttLabelUnit;
+    tickUnit: 'minute' | 'hour' | 'day' | 'week' | 'month';
+    unitPerTick: number;
+    dragStepUnit: 'minute' | 'hour' | 'day' | 'week';
+    dragStepAmount: number;
+    basePxPerDragStep: number;
+    formatTickLabel?: (date: Dayjs) => string;
+    formatHeaderLabel?: (date: Dayjs) => string;
+}
+/**
+ * Replaces the generated labels of one scale
+ * Every entry is optional - 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;
+    /** Drag tooltip and drag guide label */
+    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;
+}
+/** The three label formatters resolved for one scale */
+export interface GanttFormatters {
+    tick: (date: Dayjs) => string;
+    header: (date: Dayjs) => string;
+    tooltip: (date: Dayjs) => string;
+}
+export interface GanttBottomRowCell {
+    startDate: Dayjs;
+    widthPx: number;
+}
+export interface GanttTopHeaderGroup {
+    startDate: Dayjs;
+    widthPx: number;
+    label: string;
+}
+/**
+ * A column of the task grid on the left
+ *
+ * Every header label and cell body comes from here - the library hardcodes no strings.
+ * The first column is the tree column, so indentation and the expander attach to it.
+ */
+export interface GanttColumn {
+    /** React key, and the task field read when there is no render */
+    key: string;
+    /** What to draw in the header (a string or an element) */
+    header: ReactNode;
+    /** Column width in px (default 120) */
+    width?: number;
+    /** Cell renderer - without it, task[key] is shown as a string */
+    render?: (task: TaskTransformed) => ReactNode;
+}
+/**
+ * How rows are grouped into swimlanes
+ *
+ * A string reads that field off the task; a function returns the group value
+ * itself, which doubles as the header label. Anything empty, null or undefined
+ * lands in the "Ungrouped" bucket.
+ */
+export type GanttGroupBy = string | ((task: TaskTransformed) => string | null | undefined);
+/** Anything the marker/band props accept as a date */
+export type GanttDateInput = string | Date | Dayjs;
+/** The rendered timeline range, as reported by `onRangeChange` */
+export interface GanttDateRange {
+    start: Dayjs;
+    end: Dayjs;
+}
+/**
+ * How many extra ticks the rendered range carries beyond the tasks' own span
+ *
+ * Grows as the user scrolls past an edge; measured in ticks of the current scale, so it
+ * is reset whenever the scale changes.
+ */
+export interface GanttRangeExtension {
+    before: number;
+    after: number;
+}
+/** A labelled vertical line at one date - deadlines, releases, and the built-in today line */
+export interface GanttMarker {
+    /** React key (default: the date) */
+    id?: string;
+    date: GanttDateInput;
+    /** Text shown at the top of the line - omitted, the line is drawn bare */
+    label?: string;
+    /** Extra class on the marker element */
+    className?: string;
+    /** Line color - any CSS color, overrides the class and the theme default */
+    color?: string;
+    /**
+     * Turn the marker into a warning (`data-warning="true"`) once a task ends past its date
+     *
+     * Checks every task, or only `taskIds` when that is given.
+     */
+    warnOnOverrun?: boolean;
+    /** Limits `warnOnOverrun` to these tasks */
+    taskIds?: string[];
+}
+/** A shaded band covering a date range - sprints, phases, freezes */
+export interface GanttRangeBand {
+    /** React key (default: the start date) */
+    id?: string;
+    startDate: GanttDateInput;
+    endDate: GanttDateInput;
+    /** Text shown at the top of the band */
+    label?: string;
+    /** Extra class on the band element */
+    className?: string;
+    /** Fill color - any CSS color, overrides the class and the theme default */
+    color?: string;
+}
+/**
+ * What a row drag committed - everything needed to persist the move
+ *
+ * Returning `false` from the callback cancels the drop: nothing is written to the chart and
+ * `onTasksChange` does not fire.
+ */
+export interface GanttReorderChange {
+    /** The moved task, already carrying its new parentId and sequence */
+    task: Task;
+    /** The new parent (null = root) */
+    parentId: string | null;
+    /** The parent the task had in the incoming data, untouched by normalization */
+    previousParentId: string | null;
+    /** Zero-based position among the new parent's children */
+    index: number;
+    /** The moved task's new dotted sequence */
+    sequence: string;
+    /** The whole updated array - the same one onTasksChange receives */
+    tasks: Task[];
+}
+export interface GanttDragOffset {
+    offsetX: number;
+    offsetWidth: number;
+    offsetStartDate: Dayjs;
+    offsetEndDate: Dayjs;
+}
+/** What a gesture is about to write */
+export type GanttChangeType = 'move' | 'resize' | 'progress';
+/**
+ * The mutation a finished gesture wants to commit
+ *
+ * Handed to `onBeforeTaskChange` before anything is written, so a host can send it to a
+ * server and answer with a veto.
+ */
+export interface GanttTaskChange {
+    type: GanttChangeType;
+    /** The bar the user grabbed */
+    task: Task;
+    /** Only the tasks this gesture rewrites - dragging a summary bar carries its whole subtree */
+    changedTasks: Task[];
+    /** Those same tasks as they were before the gesture, in the same order */
+    previousTasks: Task[];
+    /** The full array the chart would hand to `onTasksChange` */
+    tasks: Task[];
+    /** Which edge moved - `resize` only */
+    edge?: 'start' | 'end';
+}
+/**
+ * Runs before a gesture is committed and can cancel it
+ *
+ * Returning `false`, a promise resolving to `false`, or a rejected promise rolls the bar
+ * back to where it started. Anything else commits. While the promise is pending the bar
+ * stays where it was dropped, so the UI never blocks on the round trip.
+ */
+export type GanttBeforeChangeHandler = (change: GanttTaskChange) => boolean | void | Promise<boolean | void>;
+/** Props handed to a `renderBar` override */
+export interface GanttBarRenderProps {
+    task: TaskTransformed;
+    /** Left offset from the timeline origin in px, live drag offset included */
+    left: number;
+    /** Rendered bar width in px, live drag offset included */
+    width: number;
+    /** Row height available to the bar in px */
+    height: number;
+    /** Progress 0-100, or null when the task has none */
+    progress: number | null;
+    scale: GanttScaleKey;
+    isMilestone: boolean;
+    isSummary: boolean;
+    isDragging: boolean;
+    isSelected: boolean;
+    /**
+     * Spread onto the root node of the replacement
+     *
+     * Carries the positioning style plus the drag, click and double-click handlers, so a
+     * custom bar keeps behaving like the default one.
+     */
+    barProps: {
+        style: CSSProperties;
+        onPointerDown: PointerEventHandler<HTMLDivElement>;
+        onClick: MouseEventHandler<HTMLDivElement>;
+        onDoubleClick: MouseEventHandler<HTMLDivElement>;
+    };
+}
+export type GanttBarRenderer = (props: GanttBarRenderProps) => ReactNode;
+/** Why a tooltip is showing */
+export type GanttTooltipReason = 'hover' | 'move' | 'resize' | 'progress';
+/** Props handed to a `renderTooltip` override */
+export interface GanttTooltipRenderProps {
+    task: TaskTransformed;
+    reason: GanttTooltipReason;
+    /** Start being previewed - the live drag value while a gesture is running */
+    startDate: Dayjs;
+    /** End being previewed - equal to `startDate` for a milestone */
+    endDate: Dayjs;
+    /** End minus start in milliseconds */
+    durationMs: number;
+    /** Progress 0-100, or null when the task has none */
+    progress: number | null;
+    scale: GanttScaleKey;
+}
+export type GanttTooltipRenderer = (props: GanttTooltipRenderProps) => ReactNode;
+/** Props handed to a `renderHeaderCell` override */
+export interface GanttHeaderCellRenderProps {
+    /** `'top'` is a merged group label, `'bottom'` a single time tick */
+    row: 'top' | 'bottom';
+    date: Dayjs;
+    /** The label the default header would print */
+    label: string;
+    width: number;
+    scale: GanttScaleKey;
+    /** Spread onto the root node of the replacement to keep the header layout intact */
+    cellProps: {
+        className: string;
+        style: CSSProperties;
+    };
+}
+export type GanttHeaderCellRenderer = (props: GanttHeaderCellRenderProps) => ReactNode;
+/** Everything a bar needs from the chart's props - passed as one object rather than eight */
+export interface GanttBarOptions {
+    onTasksChange?: (updatedTasks: Task[]) => void;
+    onBeforeTaskChange?: GanttBeforeChangeHandler;
+    onTaskClick?: (task: TaskTransformed, event: ReactMouseEvent) => void;
+    onTaskDoubleClick?: (task: TaskTransformed, event: ReactMouseEvent) => void;
+    renderBar?: GanttBarRenderer;
+    renderTooltip?: GanttTooltipRenderer;
+    /** Hover and drag tooltips, on unless explicitly turned off */
+    showTooltip?: boolean;
+}

package/dist/types/task.d.ts

@@ -0,0 +1,111 @@
+import { Task, TaskDependency } from '../core/types';
+export { isMilestoneTask, normalizeProgress } from '../core/types';
+export type { DependencyType, Task, TaskDependency, TaskType, } from '../core/types';
+/**
+ * Chart-wide interaction settings
+ *
+ * Every field is optional, and a task's own field of the same name wins over it.
+ * With nothing set, every gesture is allowed and there are no drag bounds - except
+ * drawing new tasks, which needs an `onTaskCreate` callback to go anywhere.
+ */
+export interface GanttInteractionConfig {
+    readOnly?: boolean;
+    allowMove?: boolean;
+    allowResize?: boolean;
+    allowProgressChange?: boolean;
+    allowLinkCreate?: boolean;
+    allowLinkDelete?: boolean;
+    allowTaskCreate?: boolean;
+    minDate?: string;
+    maxDate?: string;
+}
+export interface ResolvedTaskInteraction {
+    canMove: boolean;
+    canResize: boolean;
+    canChangeProgress: boolean;
+    canCreateLink: boolean;
+    canDeleteLink: boolean;
+    minDate?: string;
+    maxDate?: string;
+}
+/**
+ * Resolves what one task allows, most specific setting first:
+ *
+ * `task.allowX` > `task.readOnly` > `config.allowX` > `config.readOnly` > allowed
+ *
+ * A capability flag always beats a blanket `readOnly` at the same level, so
+ * `readOnly` on the chart plus `allowProgressChange: true` on one task means
+ * "frozen except that one progress bar".
+ *
+ * Two structural rules are not flags and cannot be flagged back on, because the
+ * gesture has nowhere to write to: milestones are never resizable (they are a
+ * single point), and summary rows are never resizable and have no draggable
+ * progress (both are rolled up from their children, so an edit would snap back).
+ * Moving a summary is fine - it carries its whole subtree.
+ */
+export declare function resolveTaskInteraction(task: Pick<Task, 'type' | 'readOnly' | 'allowMove' | 'allowResize' | 'allowProgressChange' | 'allowLinkCreate' | 'allowLinkDelete' | 'minDate' | 'maxDate'> & {
+    isSummary?: boolean;
+}, config?: GanttInteractionConfig): ResolvedTaskInteraction;
+/**
+ * Whether drawing a new task on empty timeline space is allowed
+ * Chart-wide only - the gesture starts on a row, not on a task
+ */
+export declare function canCreateTasks(config?: GanttInteractionConfig): boolean;
+/**
+ * CSS custom properties a colored bar sets
+ *
+ * Every value is a fallback for a theme token, so an empty object means the CSS
+ * defaults keep deciding - a task without a color renders exactly as before.
+ */
+export interface TaskColorVars {
+    '--gantt-bar-color'?: string;
+    '--gantt-bar-color-hover'?: string;
+    '--gantt-progress-color'?: string;
+}
+/**
+ * Resolves a task's color into the variables the stylesheet reads
+ *
+ * Precedence: the task's own `color` wins; a missing or blank one resolves to nothing,
+ * which leaves `--gantt-bar-bg` / `--gantt-progress-bg` (and any host override of them)
+ * in charge. The progress fill and the hover shade are always derived from the bar color
+ * rather than read from a token, so a colored bar never mixes in the theme gray.
+ */
+export declare function resolveTaskColors(color: string | undefined): TaskColorVars;
+export interface TaskTransformed extends Task {
+    barLeft: number;
+    barWidth: number;
+    depth: number;
+    order: number;
+    originalOrder: number;
+    /**
+     * A summary row with children (true only when hierarchy is on)
+     *
+     * Its start/end are recomputed from the children, so resizing and progress editing are
+     * disabled and dragging the bar moves the whole subtree.
+     */
+    isSummary?: boolean;
+    dependencies?: TaskDependency[];
+    /** Baseline bar geometry - present only when the task carries baseline dates */
+    baselineLeft?: number;
+    baselineWidth?: number;
+    /** CPM outputs - present only while the `criticalPath` prop is on (read-only) */
+    earlyStart?: string;
+    earlyFinish?: string;
+    lateStart?: string;
+    lateFinish?: string;
+    totalSlack?: number;
+    freeSlack?: number;
+    critical?: boolean;
+    /** Duration in calendar days, or working days when the working-day calendar is on */
+    duration?: number;
+}
+export interface RenderedDependency extends TaskDependency {
+    /** Id of the successor that owns this dependency (`targetId` is the predecessor) */
+    sourceId: string;
+    fromX: number;
+    fromY: number;
+    toX: number;
+    toY: number;
+    /** True when this link sits on the critical path */
+    critical?: boolean;
+}

package/dist/utils/a11y.d.ts

@@ -0,0 +1,141 @@
+import { Dayjs } from 'dayjs';
+import { GanttDragMode, GanttScaleKey } from '../types/gantt';
+import { GanttInteractionConfig, Task, TaskTransformed } from '../types/task';
+import { GanttRow } from './grouping';
+/** How much one `+`/`-` press moves the progress, in percentage points */
+export declare const PROGRESS_STEP = 5;
+/** Which cell of which row has the roving tabindex */
+export interface GanttFocus {
+    row: number;
+    col: number;
+}
+/** What one row offers the keyboard - all the navigation math needs */
+export interface GanttKeyboardRow {
+    /** Number of focusable cells in the row */
+    cells: number;
+    /** Cell index the bars start at (equal to `cells` when the row has none) */
+    firstBarCell: number;
+    /** Whether the row can be expanded/collapsed at all */
+    expandable: boolean;
+    /** Current state of an expandable row */
+    expanded: boolean;
+}
+export type GanttKeyAction = 
+/** Move the roving tabindex */
+{
+    kind: "focus";
+    focus: GanttFocus;
+}
+/** Expand or collapse the row */
+ | {
+    kind: "toggle";
+    row: number;
+    col: number;
+}
+/** Enter/Space on a row that cannot be expanded */
+ | {
+    kind: "activate";
+    row: number;
+    col: number;
+} | {
+    kind: "delete";
+    row: number;
+    col: number;
+}
+/** Move or resize by whole drag steps */
+ | {
+    kind: "nudge";
+    row: number;
+    col: number;
+    mode: GanttDragMode;
+    steps: number;
+} | {
+    kind: "progress";
+    row: number;
+    col: number;
+    delta: number;
+};
+/** The parts of a keyboard event the resolver reads */
+export interface GanttKeyEvent {
+    key: string;
+    altKey?: boolean;
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+}
+/**
+ * The single keyboard map of the chart
+ *
+ * Pure on purpose: the component only has to run whatever comes back, so the
+ * whole map - including the editing shortcuts - is testable without a DOM.
+ *
+ * - arrows move between cells and rows, Home/End jump within the row and (with
+ *   ctrl/meta) to the first/last row
+ * - on the first cell of an expandable row, Right expands and Left collapses
+ *   before either moves, the usual treegrid behavior
+ * - `alt` turns the horizontal arrows into a move, `shift` into an end-edge
+ *   resize and `alt+shift` into a start-edge resize, all in whole drag steps
+ *
+ * Returns null for a key the chart does not handle, so the event is left alone.
+ */
+export declare function resolveKeyboardAction(event: GanttKeyEvent, focus: GanttFocus, rows: GanttKeyboardRow[]): GanttKeyAction | null;
+/** The task a focused cell acts on - the row's first when the focus is on a list cell */
+export declare function taskAtFocus(row: GanttRow | undefined, col: number, firstBarCell: number): TaskTransformed | undefined;
+/**
+ * The bar's spoken name, e.g. "Design phase, Mar 3 to Mar 14, 40% complete"
+ *
+ * `format` is the scale's own tooltip formatter, so the label is localized by the
+ * same setting as everything else on the chart.
+ */
+export declare function formatTaskAriaLabel(task: Pick<TaskTransformed, "name" | "startDate" | "endDate" | "type" | "isSummary">, format: (date: Dayjs) => string, progress?: number | null): string;
+/** ARIA attributes of a treegrid row - spread straight onto the element */
+export interface GanttRowAria {
+    role: "row";
+    "aria-level": number;
+    "aria-posinset": number;
+    "aria-setsize": number;
+    "aria-rowindex": number;
+    "aria-expanded"?: boolean;
+    /**
+     * The bars of the row
+     *
+     * They live in the timeline, a different DOM subtree from the task list, so
+     * `aria-owns` is what makes the two panes one widget instead of two.
+     */
+    "aria-owns"?: string;
+}
+export declare function rowAriaProps(row: GanttRow, rowIndex: number, options: {
+    /** 1 when a column header row sits above the data rows, otherwise 0 */
+    headerOffset: number;
+    expandable: boolean;
+    expanded: boolean;
+    /** Element ids of the bars belonging to this row */
+    ownedIds?: string[];
+}): GanttRowAria;
+/**
+ * Moves or resizes a task by whole drag steps, the keyboard equivalent of a drag
+ *
+ * Everything a drag enforces is enforced here: `resolveTaskInteraction` decides
+ * whether the gesture is allowed at all (so a read-only chart cannot be edited by
+ * keyboard either), a summary carries its subtree, and each moving task's own
+ * min/max window clamps the shared delta.
+ *
+ * Returns the updated task array, or null when nothing may or did change - the
+ * caller then fires no change event.
+ */
+export declare function nudgeTaskDates(rawTasks: Task[], target: TaskTransformed, mode: GanttDragMode, steps: number, scaleKey: GanttScaleKey, interaction?: GanttInteractionConfig): Task[] | null;
+/**
+ * Steps a task's progress, the keyboard equivalent of dragging the handle
+ *
+ * Returns null when progress editing is not allowed or the value would not move
+ * (already at 0 or 100).
+ */
+export declare function stepTaskProgress(rawTasks: Task[], target: TaskTransformed, delta: number, interaction?: GanttInteractionConfig): Task[] | null;
+/**
+ * Removes a task and everything under it
+ *
+ * The subtree goes too, hierarchy on or off - leaving orphans behind would move
+ * them to the root instead of deleting what the user asked for. Returns null
+ * when the task is read-only or is not in the data.
+ */
+export declare function deleteTask(rawTasks: Task[], target: TaskTransformed, interaction?: GanttInteractionConfig): Task[] | null;

package/dist/utils/arrowPath.d.ts

@@ -0,0 +1,66 @@
+import { RenderedDependency, TaskTransformed } from '../types/task';
+import { LinkAnchor } from './dependency';
+/** Live offset of the task being dragged (0 when it is not being dragged) */
+export interface DragOffset {
+    offsetX: number;
+    offsetWidth: number;
+}
+/**
+ * Returns the path string for an SVG <path> element for various dependency types.
+ * @param dependencyType - One of 'FS', 'FF', 'SF', 'SS' (with a fallback).
+ * @param startX - Starting X coordinate.
+ * @param startY - Starting Y coordinate.
+ * @param endX - Ending X coordinate.
+ * @param endY - Ending Y coordinate.
+ */
+export declare function getSmartGanttPath(dependencyType: string, startX: number, startY: number, endX: number, endY: number): string;
+/**
+ * Where one end of a task's bar sits, in timeline content coordinates
+ * The connector dots and the drag preview line have to land on the same points the
+ * committed arrow will use.
+ */
+export declare function anchorPoint(task: TaskTransformed, anchor: LinkAnchor, offset?: DragOffset): {
+    x: number;
+    y: number;
+};
+/**
+ * Computes the arrow coordinates for a single dependency.
+ * targetTask is the predecessor, sourceTask the successor that owns the dependency.
+ * Returns null for an unknown dependency type (only that arrow is skipped).
+ */
+export declare function calculateArrowCoords(sourceTask: TaskTransformed, targetTask: TaskTransformed, sourceOffset: DragOffset, targetOffset: DragOffset, depType: string): {
+    fromX: number;
+    fromY: number;
+    toX: number;
+    toY: number;
+} | null;
+/**
+ * Index for looking up tasks by id.
+ *
+ * Built once whenever the task array changes and then reused - scanning the array
+ * for every dependency costs time proportional to the square of the task count,
+ * and that cost would be paid again on every drag frame.
+ */
+export declare function buildTaskIndex(transformedTasks: TaskTransformed[]): Map<string, TaskTransformed>;
+/** Visible area used for arrow culling */
+export interface ArrowViewport {
+    /** Vertical visible range (in row-virtualization terms, px) */
+    topPx: number;
+    bottomPx: number;
+    /** Horizontal visibility - reuses the column virtualization's bar visibility check */
+    isBarVisible: (left: number, width: number) => boolean;
+}
+/**
+ * Decides whether an arrow overlaps the visible area.
+ *
+ * It looks at the bounding box of the two endpoints, so a line is still drawn when
+ * both ends are off-screen but it crosses the viewport. The elbowed path runs a
+ * little past the endpoints, hence the slack.
+ */
+export declare function isArrowVisible(dep: Pick<RenderedDependency, "fromX" | "fromY" | "toX" | "toY">, viewport: ArrowViewport): boolean;
+/**
+ * Builds the dependency array.
+ * The index doubles as the iteration source and the lookup table
+ * (insertion order = task order).
+ */
+export declare function buildDependencies(taskById: Map<string, TaskTransformed>, liveOffsets: Record<string, DragOffset>, criticalLinkIds?: Set<string>): RenderedDependency[];

package/dist/utils/dependency.d.ts

@@ -0,0 +1,42 @@
+import { DependencyType, Task, TaskDependency } from '../types/task';
+/** Which end of a bar a link gesture grabbed */
+export type LinkAnchor = "start" | "end";
+/** Why a proposed link cannot be created */
+export type LinkRejection = "self" | "duplicate" | "cycle";
+/** The minimum a task needs for the dependency math - TaskTransformed fits as-is */
+type DependencyNode = Pick<Task, "id"> & {
+    dependencies?: TaskDependency[];
+};
+/**
+ * Dependency type from the two ends a drag connected
+ *
+ * The bar the drag starts on is the predecessor and the bar it is dropped on the
+ * successor, so the first letter is the predecessor's end and the second the
+ * successor's: end -> start is FS, start -> start SS, end -> end FF, start -> end SF.
+ */
+export declare function linkTypeFromAnchors(from: LinkAnchor, to: LinkAnchor): DependencyType;
+/**
+ * Checks a proposed link before it is committed - null means it may be created
+ *
+ * `task.dependencies` lists that task's predecessors, so the new entry lands on the
+ * successor and points at the predecessor.
+ *
+ * The cycle check walks the predecessor chain up from the proposed predecessor:
+ * reaching the successor means the link would close a loop. Every node walked is
+ * recorded, so a cycle already present in the data ends the walk instead of spinning
+ * (the same guard `buildTaskTree` uses for the parentId chain).
+ */
+export declare function validateDependency(tasks: DependencyNode[], predecessorId: string, successorId: string): LinkRejection | null;
+/** Human-readable reason, shown on the drag preview */
+export declare const LINK_REJECTION_LABEL: Record<LinkRejection, string>;
+/**
+ * The tasks with one dependency added to the successor
+ * Returns the same array when the successor is not in the data
+ */
+export declare function addDependency(tasks: Task[], predecessorId: string, successorId: string, type: DependencyType): Task[];
+/**
+ * The tasks with one dependency removed from the successor
+ * Returns the same array when there is nothing to remove
+ */
+export declare function removeDependency(tasks: Task[], predecessorId: string, successorId: string): Task[];
+export {};