@ganttloom/gantt-core 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,753 @@
+/**
+ * Global working-time definition: which weekdays are worked, plus a list of
+ * one-off non-working dates (holidays). Both are optional — an unset
+ * `workingDays` defaults to Mon-Fri, an unset `holidays` list is empty.
+ */
+interface WorkingCalendar {
+    /** index 0 = Sunday ... 6 = Saturday. Defaults to Mon-Fri working. */
+    workingDays?: boolean[];
+    /** ISO "YYYY-MM-DD" dates that are non-working regardless of weekday. */
+    holidays?: string[];
+    /**
+     * Daily working window, hour-of-day 0-24 (e.g. { start: 9, end: 17 }).
+     * Only affects `isWorkingTime`/`shiftToWorkingTime` and hour-level tick
+     * shading - task durations stay wall-clock (a 3-day task is still 3
+     * calendar days, not 3 working-window days); this narrows *anchor
+     * points* to the working window, it doesn't re-derive duration math.
+     */
+    workingHours?: {
+        start: number;
+        end: number;
+    };
+}
+declare function isHoliday(date: Date, calendar?: WorkingCalendar): boolean;
+declare function isWorkingDay(date: Date, calendar?: WorkingCalendar): boolean;
+/** Next working day at/after `date` (same time-of-day), scanning forward at most 366 days. */
+declare function nextWorkingDay(date: Date, calendar?: WorkingCalendar): Date;
+/** Previous working day at/before `date` (same time-of-day), scanning backward at most 366 days. */
+declare function previousWorkingDay(date: Date, calendar?: WorkingCalendar): Date;
+/**
+ * Nudge `date` onto a working day if it isn't already, moving in `direction`
+ * (1 = forward, -1 = backward). No-op (besides cloning) when no calendar is given
+ * or `date` is already a working day.
+ */
+declare function shiftToWorkingDay(date: Date, calendar: WorkingCalendar | undefined, direction: 1 | -1): Date;
+declare function isWithinWorkingHours(date: Date, calendar?: WorkingCalendar): boolean;
+/** Working day AND (no workingHours set, or within them). */
+declare function isWorkingTime(date: Date, calendar?: WorkingCalendar): boolean;
+/**
+ * Like shiftToWorkingDay, but also snaps onto the daily working-hours window
+ * when one is configured: forward past a day's end (or on a non-working day)
+ * moves to the next working day's start; backward before a day's start (or
+ * on a non-working day) moves to the previous working day's end. No-op
+ * without a calendar.
+ */
+declare function shiftToWorkingTime(date: Date, calendar: WorkingCalendar | undefined, direction: 1 | -1): Date;
+
+/**
+ * MSP-style task constraint types.
+ *
+ * "asap" and "alap" are intentionally no-ops in this engine: a true ALAP
+ * (as-late-as-possible) schedule requires a backward pass from the project
+ * end date, which isn't something a purely local, per-drag/per-cascade
+ * engine can do without a full re-solve. The other six are hard date
+ * constraints applied locally, which fit the same incremental model used
+ * by dependency cascading.
+ */
+type ConstraintType = "asap" | "alap" | "snet" | "snlt" | "fnet" | "fnlt" | "mso" | "mfo";
+interface DateRange {
+    start: Date;
+    end: Date;
+}
+/**
+ * Adjust [start, end] to satisfy a constraint, preserving the task's
+ * duration. No-op if `constraintType` or `constraintDate` is unset, or the
+ * range already satisfies the constraint.
+ */
+declare function applyConstraint(range: DateRange, constraintType: ConstraintType | undefined, constraintDate: Date | undefined): DateRange;
+
+type ViewMode = "hour" | "day" | "week" | "month" | "quarter" | "year";
+type DependencyType = "FS" | "SS" | "FF" | "SF";
+
+interface GanttDependency {
+    /** id of the predecessor task */
+    fromId: string;
+    /** id of the successor task */
+    toId: string;
+    type: DependencyType;
+    /** optional lag/lead in milliseconds, negative = lead */
+    lagMs?: number;
+}
+interface GanttAssignee {
+    id: string;
+    name: string;
+    /** image URL; if omitted, initials are derived from name */
+    avatarUrl?: string;
+    color?: string;
+}
+interface GanttTask {
+    id: string;
+    name: string;
+    start: Date;
+    end: Date;
+    /** 0-100 */
+    progress?: number;
+    parentId?: string | null;
+    /** true if this task is a group/summary row (auto-computed span from children if not set) */
+    isGroup?: boolean;
+    /** render as a diamond marker instead of a bar; auto-detected when start equals end */
+    isMilestone?: boolean;
+    collapsed?: boolean;
+    color?: string;
+    progressColor?: string;
+    /** disallow drag/resize interactions for this task */
+    readonly?: boolean;
+    /** original planned dates, rendered as a faint bar behind the live bar */
+    baselineStart?: Date;
+    baselineEnd?: Date;
+    /**
+     * Render this task as multiple bar segments instead of one continuous bar
+     * (MSP-style "split task"). `start`/`end` above remain the authoritative
+     * overall envelope - keep segments within it. Dragging the whole task
+     * shifts every segment together; resizing an edge only adjusts the
+     * first (left) or last (right) segment's outer edge.
+     */
+    segments?: {
+        start: Date;
+        end: Date;
+    }[];
+    /** target completion date, rendered as a flag marker; end date past this renders as overdue */
+    deadline?: Date;
+    /** MSP-style scheduling constraint; see ConstraintType for the eight supported kinds */
+    constraintType?: ConstraintType;
+    /** the date the constraint is relative to (ignored for "asap"/"alap") */
+    constraintDate?: Date;
+    assignees?: GanttAssignee[];
+    /** shown as a native hover tooltip on the bar (an SVG <title>, so it works with zero extra markup/JS) */
+    notes?: string;
+    /** additional named baseline snapshots beyond baselineStart/baselineEnd (e.g. "as of last Friday") - rendered as extra faint bars, oldest furthest back */
+    baselines?: {
+        label: string;
+        start: Date;
+        end: Date;
+    }[];
+    /** arbitrary extra fields, referenced by grid columns */
+    data?: Record<string, unknown>;
+}
+interface GanttColumn {
+    id: string;
+    title: string;
+    width?: number;
+    /** how to read the display value for this column */
+    accessor?: (task: GanttTask) => string | number | null | undefined;
+    /** if provided, cell renders as an <a href=...> using this to compute the link target */
+    getHref?: (task: GanttTask) => string | null | undefined;
+    /**
+     * Escape hatch for rich cell content (badges, progress bars, buttons, ...):
+     * return an HTMLElement to mount directly, or a plain string rendered as
+     * text (never parsed as HTML, so this stays XSS-safe without callers
+     * needing to think about it). Takes precedence over `accessor`/`getHref`.
+     */
+    render?: (task: GanttTask) => HTMLElement | string | null | undefined;
+    /** anchor target, defaults to "_blank" */
+    linkTarget?: string;
+    align?: "left" | "center" | "right";
+}
+interface GanttTheme {
+    rowHeight: number;
+    barHeight: number;
+    headerHeight: number;
+    gridColor: string;
+    weekendColor: string;
+    todayColor: string;
+    barColor: string;
+    barProgressColor: string;
+    groupBarColor: string;
+    linkColor: string;
+    criticalColor: string;
+    baselineColor: string;
+    deadlineColor: string;
+    markerColor: string;
+    selectionColor: string;
+    textColor: string;
+    backgroundColor: string;
+    fontFamily: string;
+    fontSize: number;
+    borderRadius: number;
+}
+/**
+ * Fully-resolved, framework-agnostic geometry for one render pass.
+ * This is the bridge consumed by @ganttloom/gantt-export (PDF/PPTX)
+ * and by any custom renderer that doesn't want to reimplement layout.
+ */
+interface GanttRenderRow {
+    taskId: string;
+    y: number;
+    height: number;
+    isGroup: boolean;
+    collapsed: boolean;
+    depth: number;
+    hasChildren: boolean;
+}
+interface GanttRenderBar {
+    taskId: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    progressWidth: number;
+    color: string;
+    progressColor: string;
+    label: string;
+    isCritical: boolean;
+    isMilestone: boolean;
+    baseline?: {
+        x: number;
+        width: number;
+    };
+    /** rendered from task.baselines, oldest last (furthest back visually) */
+    baselines?: {
+        label: string;
+        x: number;
+        width: number;
+    }[];
+    /** x position of the task's deadline marker, in chart coordinate space */
+    deadlineX?: number;
+    /** true when the task's end date is past its deadline */
+    isOverdue?: boolean;
+    /** present (non-empty) when task.segments was set - x/width are local to this bar's x, like the bar itself */
+    segments?: {
+        x: number;
+        width: number;
+        progressWidth: number;
+    }[];
+    isSelected?: boolean;
+}
+interface GanttRenderLink {
+    fromId: string;
+    toId: string;
+    type: DependencyType;
+    /** SVG path "d" attribute, in chart coordinate space */
+    path: string;
+    isCritical: boolean;
+}
+/** An arbitrary labeled vertical line on the timeline, independent of any task (e.g. "Sprint boundary", "Release day"). */
+interface GanttMarker {
+    date: Date;
+    label?: string;
+    color?: string;
+}
+interface GanttRenderMarker {
+    x: number;
+    label: string;
+    color: string;
+}
+interface GanttRenderTick {
+    x: number;
+    label: string;
+    isWeekend: boolean;
+    /** weekend OR a calendar holiday; only meaningful when a WorkingCalendar was supplied */
+    isNonWorking: boolean;
+    isToday: boolean;
+    isMajorBoundary: boolean;
+}
+interface GanttRenderModel {
+    width: number;
+    height: number;
+    rowHeight: number;
+    headerHeight: number;
+    rows: GanttRenderRow[];
+    bars: GanttRenderBar[];
+    links: GanttRenderLink[];
+    ticks: GanttRenderTick[];
+    columns: GanttColumn[];
+    theme: GanttTheme;
+    markers: GanttRenderMarker[];
+    /** start of the timeline's date range, in real time - lets callers convert chart-space x back to a Date */
+    rangeStart: Date;
+}
+interface GanttOptions {
+    viewMode?: ViewMode;
+    columns?: GanttColumn[];
+    theme?: Partial<GanttTheme>;
+    /** "auto" (default) follows the OS/browser dark-mode preference and updates live if it changes */
+    colorScheme?: "light" | "dark" | "auto";
+    /** px per smallest time unit column, auto if omitted */
+    columnWidth?: number;
+    readonly?: boolean;
+    showProgress?: boolean;
+    showDependencies?: boolean;
+    gridPanelWidth?: number;
+    showCriticalPath?: boolean;
+    showBaseline?: boolean;
+    showDeadlines?: boolean;
+    showAssigneeAvatars?: boolean;
+    /** working-day/holiday definition used to shade non-working time and (with autoSchedule) skip it when cascading */
+    calendar?: WorkingCalendar;
+    /** arbitrary labeled vertical lines on the timeline, independent of any task */
+    markers?: GanttMarker[];
+    /** a group task with no explicit `progress` gets a duration-weighted average of its children's progress instead of 0 */
+    autoRollupProgress?: boolean;
+    /** enables click/ctrl-click/shift-click multi-selection of task bars, and chart.bulkShiftDates()/bulkDelete() */
+    selectable?: boolean;
+    onSelectionChange?: (taskIds: string[]) => void;
+    /** enable Ctrl+Z / Ctrl+Y undo-redo history for move/resize/link actions */
+    enableHistory?: boolean;
+    /** enable arrow-key task movement + ARIA labels on bars/rows */
+    keyboardAccessible?: boolean;
+    /** only render DOM/SVG nodes for rows within the visible viewport (+ overscan). Default true. */
+    virtualScroll?: boolean;
+    /** render only `pageSize` top-level rows for `page` (1-indexed) instead of the full tree */
+    pagination?: {
+        pageSize: number;
+        page: number;
+    };
+    /** round drag/resize deltas to this grid unit; false for raw pixel precision */
+    snapToUnit?: "hour" | "day" | "week" | false;
+    onContextMenu?: (task: GanttTask, evt: PointerEvent) => void;
+    /** when a task moves/resizes, cascade-shift dependent successors that would otherwise violate the link */
+    autoSchedule?: boolean;
+    onDateChange?: (task: GanttTask, start: Date, end: Date) => void;
+    onProgressChange?: (task: GanttTask, progress: number) => void;
+    onDependencyCreate?: (dep: GanttDependency) => void;
+    onDependencyRemove?: (dep: GanttDependency) => void;
+    /** called on double-click of a dependency link, for building your own "edit this link" UI (see chart.updateDependency) */
+    onDependencyDblClick?: (dep: GanttDependency) => void;
+    onTaskClick?: (task: GanttTask) => void;
+    onGroupToggle?: (task: GanttTask, collapsed: boolean) => void;
+    /** called when a task is created via drag-to-create on an empty timeline row */
+    onTaskCreate?: (task: GanttTask) => void;
+    /** called when a grid column is resized by dragging its header's edge */
+    onColumnResize?: (columnId: string, width: number) => void;
+    /** called when grid columns are reordered by dragging a header; `order` is the new full list of column ids */
+    onColumnReorder?: (order: string[]) => void;
+    /** called when a grid row is dragged onto another; "inside" reparents the dragged task under the target */
+    onTaskReorder?: (draggedTaskId: string, targetTaskId: string, position: "before" | "after" | "inside") => void;
+}
+type GanttEventMap = {
+    "date-change": {
+        task: GanttTask;
+        start: Date;
+        end: Date;
+    };
+    "progress-change": {
+        task: GanttTask;
+        progress: number;
+    };
+    "dependency-create": GanttDependency;
+    "dependency-remove": GanttDependency;
+    "task-click": {
+        task: GanttTask;
+    };
+    "task-create": {
+        task: GanttTask;
+    };
+    "group-toggle": {
+        task: GanttTask;
+        collapsed: boolean;
+    };
+    "tasks-change": {
+        tasks: GanttTask[];
+    };
+    "history-change": {
+        canUndo: boolean;
+        canRedo: boolean;
+    };
+    "page-change": {
+        page: number;
+        pageCount: number;
+    };
+    "context-menu": {
+        task: GanttTask;
+        evt: PointerEvent;
+    };
+    "column-resize": {
+        columnId: string;
+        width: number;
+    };
+    "column-reorder": {
+        order: string[];
+    };
+    "dependency-dblclick": GanttDependency;
+    "task-reorder": {
+        draggedTaskId: string;
+        targetTaskId: string;
+        position: "before" | "after" | "inside";
+    };
+    "selection-change": {
+        taskIds: string[];
+    };
+};
+
+interface ResourceLevelingOptions {
+    calendar?: WorkingCalendar;
+}
+interface ResourceLevelingResult {
+    /** same tasks, same order - shifted ones are shallow clones with new start/end (duration preserved) */
+    tasks: GanttTask[];
+    shifted: {
+        taskId: string;
+        delayMs: number;
+    }[];
+}
+/**
+ * Resolve resource overallocation by delaying tasks (never pulling them
+ * earlier) so no assignee is placed on more than one task on the same
+ * working day - the same "fully allocated while active" model
+ * computeResourceHistogram uses, so a leveled schedule always shows zero
+ * `overallocated` buckets afterward.
+ *
+ * Tasks are processed in an order that respects FS ("finish-to-start")
+ * dependencies (a task never gets placed before its FS predecessors
+ * finish); SS/FF/SF dependencies aren't specifically enforced by the
+ * leveler - a reasonable, documented scope limit rather than a full
+ * constraint solver.
+ */
+declare function levelResources(tasks: GanttTask[], dependencies: GanttDependency[], options?: ResourceLevelingOptions): ResourceLevelingResult;
+
+interface ResourceHistogramOptions {
+    /** hours a resource is assumed available per working day. Default 8. */
+    capacityHoursPerDay?: number;
+    /** governs which days count as "working" for allocation purposes. Non-working days get 0 load. */
+    calendar?: WorkingCalendar;
+}
+interface ResourceLoadBucket {
+    assigneeId: string;
+    assigneeName: string;
+    /** start of the day this bucket represents */
+    date: Date;
+    /** hours allocated to this assignee across all tasks spanning this day */
+    allocatedHours: number;
+    capacityHours: number;
+    overallocated: boolean;
+}
+/**
+ * Bucket every task's assignees by calendar day, summing one full day's
+ * capacity worth of allocation per assignee per working day the task spans
+ * (milestones and non-working days contribute nothing). This is a simple
+ * "fully allocated while active" model, not a percent-effort model - tasks
+ * don't carry an effort/FTE field, so it's the only allocation the plain
+ * task/assignee data can support without inventing new required fields.
+ */
+declare function computeResourceHistogram(tasks: GanttTask[], options?: ResourceHistogramOptions): ResourceLoadBucket[];
+/**
+ * Render a resource histogram as a standalone SVG string: one grouped column
+ * of stacked bars per day, one bar per assignee, red when overallocated.
+ * Framework-agnostic like the rest of gantt-core - drop the string into an
+ * `<div>` via `innerHTML` or a data URI, no DOM dependency required to call it.
+ */
+declare function renderResourceHistogramSVG(buckets: ResourceLoadBucket[], options?: {
+    width?: number;
+    barWidth?: number;
+    maxBarHeight?: number;
+    overallocatedColor?: string;
+    barColor?: string;
+}): string;
+
+declare const DEFAULT_THEME: GanttTheme;
+type ColorScheme = "light" | "dark" | "auto";
+type Density = "compact" | "comfortable" | "spacious";
+/**
+ * Row/bar/header/font sizing presets. Not wired into any option - spread one
+ * into your `theme` prop/option (explicit fields you also set win, since
+ * object spread is left-to-right):
+ *
+ *   theme: { ...DENSITY_PRESETS.compact, barColor: "#..." }
+ */
+declare const DENSITY_PRESETS: Record<Density, Pick<GanttTheme, "rowHeight" | "barHeight" | "headerHeight" | "fontSize">>;
+declare function mergeTheme(partial?: Partial<GanttTheme>, scheme?: ColorScheme): GanttTheme;
+declare function themeToCssVars(theme: GanttTheme): Record<string, string>;
+
+interface LayoutInput {
+    tasks: GanttTask[];
+    dependencies: GanttDependency[];
+    viewMode: ViewMode;
+    columnWidth: number;
+    theme: GanttTheme;
+    columns: GanttColumn[];
+    showCriticalPath?: boolean;
+    showBaseline?: boolean;
+    showDeadlines?: boolean;
+    showAssigneeAvatars?: boolean;
+    calendar?: WorkingCalendar;
+    markers?: GanttMarker[];
+    /** a group task with no explicit `progress` gets a duration-weighted average of its children's progress instead of 0 */
+    autoRollupProgress?: boolean;
+    selectedTaskIds?: Set<string>;
+    /** restrict layout to a page of top-level rows, in document order (1-indexed) */
+    pagination?: {
+        pageSize: number;
+        page: number;
+    };
+}
+declare function computeLayout(input: LayoutInput): GanttRenderModel;
+
+interface CriticalPathResult {
+    criticalTasks: Set<string>;
+    criticalLinks: Set<string>;
+}
+/**
+ * Longest-duration-chain (CPM-style forward/backward pass) through the dependency DAG.
+ * Task dates in a Gantt chart are already fixed (this isn't an auto-scheduler), so the
+ * dependency `type` and `lagMs` are folded into a single edge weight rather than
+ * recomputing actual start/end dates - the goal is only to flag which tasks/links sit
+ * on the longest chain, not to move anything.
+ */
+declare function computeCriticalPath(tasks: GanttTask[], dependencies: GanttDependency[]): CriticalPathResult;
+
+interface Command {
+    do(): void;
+    undo(): void;
+    label?: string;
+}
+type HistoryChangeListener = (state: {
+    canUndo: boolean;
+    canRedo: boolean;
+}) => void;
+declare class HistoryManager {
+    private undoStack;
+    private redoStack;
+    private onChange?;
+    constructor(onChange?: HistoryChangeListener);
+    push(cmd: Command): void;
+    undo(): boolean;
+    redo(): boolean;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    clear(): void;
+    private notify;
+}
+
+type Listener<TPayload> = (payload: TPayload) => void;
+declare class EventEmitter<TEventMap extends Record<string, unknown>> {
+    private listeners;
+    on<K extends keyof TEventMap>(event: K, listener: Listener<TEventMap[K]>): void;
+    off<K extends keyof TEventMap>(event: K, listener: Listener<TEventMap[K]>): void;
+    once<K extends keyof TEventMap>(event: K, listener: Listener<TEventMap[K]>): void;
+    emit<K extends keyof TEventMap>(event: K, payload: TEventMap[K]): void;
+    removeAllListeners(): void;
+}
+
+declare function tasksToCSV(tasks: GanttTask[]): string;
+declare function tasksFromCSV(csv: string): GanttTask[];
+
+declare const MS_PER_HOUR: number;
+declare const MS_PER_DAY: number;
+declare const MS_PER_WEEK: number;
+/** Approximate duration of one grid unit for the given view mode, used only for pixel scaling. */
+declare function approxUnitMs(viewMode: ViewMode): number;
+/** Pixels per millisecond, derived from how many px represent one grid unit. */
+declare function pxPerMs(viewMode: ViewMode, columnWidth: number): number;
+declare function dateToX(date: Date, rangeStart: Date, viewMode: ViewMode, columnWidth: number): number;
+declare function isWeekend(date: Date): boolean;
+declare function isValidDate(date: unknown): date is Date;
+declare function isSameDay(a: Date, b: Date): boolean;
+/** Snap the given date down to the start of the grid unit for the view mode. */
+declare function startOfUnit(date: Date, viewMode: ViewMode): Date;
+/** Advance (or, with a negative count, go back) `count` grid units, calendar-aware. */
+declare function addUnit(date: Date, viewMode: ViewMode, count: number): Date;
+/** Snap an arbitrary date to the nearest grid-unit boundary. */
+declare function snapToGrid(date: Date, viewMode: ViewMode): Date;
+interface GeneratedTick {
+    date: Date;
+    x: number;
+    label: string;
+    isWeekend: boolean;
+    isNonWorking: boolean;
+    isToday: boolean;
+    isMajorBoundary: boolean;
+}
+/**
+ * Generate header ticks spanning [rangeStart, rangeEnd], one per grid unit.
+ * `x` is relative to rangeStart (the caller offsets it if the model has left padding).
+ */
+declare function generateTicks(rangeStart: Date, rangeEnd: Date, viewMode: ViewMode, columnWidth: number, today?: Date, calendar?: WorkingCalendar): GeneratedTick[];
+
+type dateUtils_GeneratedTick = GeneratedTick;
+declare const dateUtils_MS_PER_DAY: typeof MS_PER_DAY;
+declare const dateUtils_MS_PER_HOUR: typeof MS_PER_HOUR;
+declare const dateUtils_MS_PER_WEEK: typeof MS_PER_WEEK;
+declare const dateUtils_addUnit: typeof addUnit;
+declare const dateUtils_approxUnitMs: typeof approxUnitMs;
+declare const dateUtils_dateToX: typeof dateToX;
+declare const dateUtils_generateTicks: typeof generateTicks;
+declare const dateUtils_isSameDay: typeof isSameDay;
+declare const dateUtils_isValidDate: typeof isValidDate;
+declare const dateUtils_isWeekend: typeof isWeekend;
+declare const dateUtils_pxPerMs: typeof pxPerMs;
+declare const dateUtils_snapToGrid: typeof snapToGrid;
+declare const dateUtils_startOfUnit: typeof startOfUnit;
+declare namespace dateUtils {
+  export { type dateUtils_GeneratedTick as GeneratedTick, dateUtils_MS_PER_DAY as MS_PER_DAY, dateUtils_MS_PER_HOUR as MS_PER_HOUR, dateUtils_MS_PER_WEEK as MS_PER_WEEK, dateUtils_addUnit as addUnit, dateUtils_approxUnitMs as approxUnitMs, dateUtils_dateToX as dateToX, dateUtils_generateTicks as generateTicks, dateUtils_isSameDay as isSameDay, dateUtils_isValidDate as isValidDate, dateUtils_isWeekend as isWeekend, dateUtils_pxPerMs as pxPerMs, dateUtils_snapToGrid as snapToGrid, dateUtils_startOfUnit as startOfUnit };
+}
+
+/**
+ * Only http(s), mailto, and scheme-relative/relative URLs are allowed in a getHref() cell -
+ * anything else (javascript:, data:, vbscript:, etc.) renders as plain text instead of a link.
+ */
+declare function isSafeHref(url: string): boolean;
+
+/** A readable, colorblind-considerate categorical palette; cycles if there are more distinct values than colors. */
+declare const DEFAULT_PALETTE: string[];
+/**
+ * Assign a stable color to each distinct value of `field(task)` across `tasks`,
+ * cycling through `palette` in first-seen order. Pure - returns a lookup map,
+ * doesn't touch the tasks themselves (use with `applyColorByField` or your own
+ * `task.color = colors.get(field(task))` loop).
+ */
+declare function colorByField(tasks: GanttTask[], field: (task: GanttTask) => string | null | undefined, palette?: string[]): Map<string, string>;
+/** Convenience wrapper: returns a new tasks array with `.color` set from `colorByField`'s result (a task's existing `.color` wins if already set). */
+declare function applyColorByField(tasks: GanttTask[], field: (task: GanttTask) => string | null | undefined, palette?: string[]): GanttTask[];
+
+/**
+ * Compute Work Breakdown Structure codes ("1", "1.1", "1.2", "2", ...) from
+ * task parent/child nesting, in document (array) order among siblings.
+ *
+ * Returned as a plain Map rather than mutating tasks, matching the library's
+ * "everything is a plain object, the chart never owns your state" principle -
+ * wire it into a grid column via `column.accessor` if you want it displayed:
+ *
+ *   const wbs = computeWBSCodes(tasks);
+ *   columns: [{ id: "wbs", title: "WBS", accessor: (t) => wbs.get(t.id) }]
+ *
+ * A task whose `parentId` doesn't resolve to another task in the list is
+ * treated as a root, same as an unset `parentId`.
+ */
+declare function computeWBSCodes(tasks: GanttTask[]): Map<string, string>;
+
+interface FilterTasksOptions {
+    /** keep ancestors of a matched task so its tree path stays intact. Default true. */
+    includeAncestors?: boolean;
+    /** keep descendants of a matched task (e.g. a matched group's children). Default true. */
+    includeDescendants?: boolean;
+}
+interface FilterTasksResult {
+    /** the subset of `tasks` to keep, in original order - pass straight to the chart's `tasks` prop/setTasks to hide the rest */
+    tasks: GanttTask[];
+    /** ids that satisfied `predicate` directly, as opposed to being pulled in via includeAncestors/includeDescendants - use to dim rows that are shown only for tree context */
+    matchedIds: Set<string>;
+}
+/**
+ * Filter tasks by a predicate while keeping the tree intact: a matched
+ * task's ancestors stay (so it doesn't vanish along with a non-matching
+ * parent) and, by default, its descendants stay too (so a matched group
+ * doesn't show with its children silently missing).
+ *
+ * This only computes the subset - hook it up by passing `result.tasks` as
+ * the chart's `tasks` (non-matches are hidden because they're no longer in
+ * the array, same as any other plain-data filter), and optionally use
+ * `result.matchedIds` to visually dim tasks that are present only for tree
+ * context (e.g. via a `column.accessor` or `task.color` override).
+ */
+declare function filterTasks(tasks: GanttTask[], predicate: (task: GanttTask) => boolean, options?: FilterTasksOptions): FilterTasksResult;
+
+declare class GanttChart {
+    private container;
+    private tasks;
+    private dependencies;
+    private options;
+    private theme;
+    private colorScheme;
+    private darkMediaQuery;
+    private handleSchemeChange;
+    private explicitTheme?;
+    private columns;
+    private columnWidth;
+    private emitter;
+    private history;
+    private renderer;
+    private interactions;
+    private renderModel;
+    private rafHandle;
+    private currentPage;
+    private selectedTaskIds;
+    private lastSelectedId;
+    constructor(container: HTMLElement, tasks: GanttTask[], dependencies?: GanttDependency[], options?: GanttOptions);
+    private setupDom;
+    private handleMove;
+    private handleResize;
+    private applyDateChange;
+    private emitDateChangeEvents;
+    /** Shift successors that would violate their dependency constraint after `taskId` moves to [newStart, newEnd]. */
+    private computeCascade;
+    private handleLinkComplete;
+    removeDependency(fromId: string, toId: string): void;
+    /** Update a dependency's type/lag in place (e.g. from your own "edit this link" UI opened via onDependencyDblClick). Undoable. */
+    updateDependency(fromId: string, toId: string, partial: Partial<GanttDependency>): void;
+    private handleProgressDrag;
+    private handleCreateTaskDrag;
+    private handleBarClick;
+    /** Replace (default) or add to (`additive: true`) the current selection. Requires `selectable`. */
+    selectTask(id: string, options?: {
+        additive?: boolean;
+    }): void;
+    clearSelection(): void;
+    getSelectedTaskIds(): string[];
+    /** Shift every selected task's start/end by `deltaMs`. Single undoable step. */
+    bulkShiftDates(deltaMs: number): void;
+    /** Delete every selected task (and any dependency touching one). Single undoable step. */
+    bulkDelete(): void;
+    private runCommand;
+    private handleColumnResize;
+    private handleColumnReorder;
+    private handleRowReorder;
+    toggleGroup(taskId: string): void;
+    expandAll(): void;
+    collapseAll(): void;
+    setTasks(tasks: GanttTask[]): void;
+    getTasks(): GanttTask[];
+    setDependencies(deps: GanttDependency[]): void;
+    updateTask(id: string, partial: Partial<GanttTask>): void;
+    setViewMode(mode: ViewMode): void;
+    setOptions(partial: Partial<GanttOptions>): void;
+    /** Scroll the timeline so "today" is centered in the viewport. No-op without a DOM / today column visible. */
+    scrollToToday(): void;
+    /** Scroll the timeline to the very start of the project's date range. Also the Home-key shortcut when keyboardAccessible. */
+    scrollToRangeStart(): void;
+    /** Scroll the timeline to the very end of the project's date range. Also the End-key shortcut when keyboardAccessible. */
+    scrollToRangeEnd(): void;
+    /** Select every currently visible task. Also the Ctrl/Cmd+A shortcut when both `selectable` and `keyboardAccessible` are on. */
+    selectAllVisible(): void;
+    fitToViewport(containerWidthPx: number): void;
+    private static readonly MIN_COLUMN_WIDTH;
+    private static readonly MAX_COLUMN_WIDTH;
+    /** Zoom in by `factor` (default 1.25x), clamped to a sane minimum column width. */
+    zoomIn(factor?: number): void;
+    /** Zoom out by `factor` (default 1.25x), clamped to a sane maximum column width. */
+    zoomOut(factor?: number): void;
+    /** Current zoom level, expressed as px per grid-unit column (same unit as the `columnWidth` option). */
+    getZoomLevel(): number;
+    /** Per-assignee daily workload, computed from the current tasks. See computeResourceHistogram. */
+    getResourceHistogram(options?: ResourceHistogramOptions): ResourceLoadBucket[];
+    /** Resolve resource overallocation by delaying tasks. Doesn't mutate state - call setTasks(result.tasks) to apply it. See levelResources. */
+    getLeveledTasks(options?: ResourceLevelingOptions): ResourceLevelingResult;
+    getPageCount(): number;
+    setPage(page: number): void;
+    getRenderModel(): GanttRenderModel;
+    private computeModel;
+    private scheduleRender;
+    private doRender;
+    undo(): void;
+    redo(): void;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    on<K extends keyof GanttEventMap>(event: K, listener: (payload: GanttEventMap[K]) => void): void;
+    off<K extends keyof GanttEventMap>(event: K, listener: (payload: GanttEventMap[K]) => void): void;
+    toSVGString(): string;
+    private rasterizeSVG;
+    toPNGDataURL(): Promise<string>;
+    /**
+     * Like toPNGDataURL, but tiles a chart larger than `pageWidthPx`/`pageHeightPx`
+     * into multiple images (row-major order) instead of one oversized raster -
+     * useful for charts too big to comfortably rasterize/view as a single PNG.
+     * Reuses the full rendered SVG (so every page renders at full fidelity);
+     * defaults to the chart's actual size, i.e. a single image, when omitted.
+     */
+    toPNGDataURLs(options?: {
+        pageWidthPx?: number;
+        pageHeightPx?: number;
+    }): Promise<string[]>;
+    destroy(): void;
+}
+
+export { type Command, type ConstraintType, DEFAULT_PALETTE, DEFAULT_THEME, DENSITY_PRESETS, type Density, type DependencyType, EventEmitter, type FilterTasksOptions, type FilterTasksResult, type GanttAssignee, GanttChart, type GanttColumn, type GanttDependency, type GanttEventMap, type GanttMarker, type GanttOptions, type GanttRenderBar, type GanttRenderLink, type GanttRenderMarker, type GanttRenderModel, type GanttRenderRow, type GanttRenderTick, type GanttTask, type GanttTheme, HistoryManager, type ResourceHistogramOptions, type ResourceLevelingOptions, type ResourceLevelingResult, type ResourceLoadBucket, type ViewMode, type WorkingCalendar, applyColorByField, applyConstraint, colorByField, computeCriticalPath, computeLayout, computeResourceHistogram, computeWBSCodes, dateUtils, filterTasks, isHoliday, isSafeHref, isWithinWorkingHours, isWorkingDay, isWorkingTime, levelResources, mergeTheme, nextWorkingDay, previousWorkingDay, renderResourceHistogramSVG, shiftToWorkingDay, shiftToWorkingTime, tasksFromCSV, tasksToCSV, themeToCssVars };