@svgrid/enterprise 3.0.2 → 3.1.0

package/dist/gantt/SvGridGantt.svelte.d.ts

@@ -0,0 +1,30 @@
+import type { ColumnDef, GanttConfig, RowData, TableFeatures } from "@svgrid/grid";
+declare function $$render<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData>(): {
+    props: {
+        data: ReadonlyArray<TData>;
+        columns: Array<ColumnDef<TFeatures, TData>>;
+        gantt: GanttConfig<TFeatures, TData>;
+        getRowId?: (row: TData, index: number) => string;
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData> {
+    props(): ReturnType<typeof $$render<TFeatures, TData>>['props'];
+    events(): ReturnType<typeof $$render<TFeatures, TData>>['events'];
+    slots(): ReturnType<typeof $$render<TFeatures, TData>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TFeatures, TData>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TFeatures, TData>['props']>, ReturnType<__sveltets_Render<TFeatures, TData>['events']>, ReturnType<__sveltets_Render<TFeatures, TData>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TFeatures, TData>['bindings']>;
+    } & ReturnType<__sveltets_Render<TFeatures, TData>['exports']>;
+    <TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData>(internal: unknown, props: ReturnType<__sveltets_Render<TFeatures, TData>['props']> & {}): ReturnType<__sveltets_Render<TFeatures, TData>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
+}
+declare const SvGridGantt: $$IsomorphicComponent;
+type SvGridGantt<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData> = InstanceType<typeof SvGridGantt<TFeatures, TData>>;
+export default SvGridGantt;

package/dist/gantt/gantt-config.d.ts

@@ -0,0 +1,73 @@
+/**
+ * GanttProConfig - the Enterprise superset of the free grid {@link GanttConfig}.
+ * The `gantt` prop and its base config type ship in `@svgrid/grid`; the Pro
+ * renderer (SvGridGantt) reads these extra fields at runtime through a cast
+ * (the renderer is registered untyped, so nothing in the free grid needs to
+ * know about them). Consumers using Pro features type their config as
+ * `GanttProConfig` - it is structurally assignable to the `gantt` prop.
+ *
+ * Mirrors `scheduler-config.ts`, which does the same for the calendar.
+ */
+import type { GanttConfig, RowData, SchedulerResource, TableFeatures } from '@svgrid/grid';
+/**
+ * How a task's dates are pinned, in the classic planning vocabulary:
+ * `ASAP` (the default - schedule as early as links allow), `ALAP` (as late as
+ * possible), `MSO` / `MFO` (must start / finish on the constraint date),
+ * `SNET` / `SNLT` (start no earlier / later than), `FNET` / `FNLT` (finish no
+ * earlier / later than).
+ */
+export type GanttConstraint = 'ASAP' | 'ALAP' | 'MSO' | 'MFO' | 'SNET' | 'SNLT' | 'FNET' | 'FNLT';
+export type GanttProConfig<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData> = GanttConfig<TFeatures, TData> & {
+    /**
+     * Highlight the critical path: the chain of linked tasks with no slack,
+     * where any slip moves the project's finish. Needs `dependencies`.
+     */
+    criticalPath?: boolean;
+    /** Fired with the critical task ids whenever the path is recomputed. */
+    onCriticalPathChange?: (keys: string[]) => void;
+    /**
+     * Fields holding the BASELINE (originally agreed) dates, drawn as a ghost bar
+     * under each task so drift from the plan is visible.
+     */
+    baselineStartField?: keyof TData & string;
+    baselineEndField?: keyof TData & string;
+    /**
+     * Per-row scheduling constraint (see {@link GanttConstraint}) and the date it
+     * refers to. A cascade that would violate one stops at the constraint and the
+     * bar is flagged rather than moved past it.
+     */
+    constraintField?: keyof TData & string;
+    constraintDateField?: keyof TData & string;
+    /**
+     * Fold whole non-working days out of the axis: a weekend shrinks to a narrow
+     * hatched gap instead of two empty columns, so a year of plan fits in the
+     * width a season used to take. Bars that do run over a folded weekend still
+     * draw across it.
+     *
+     * Only the day-granular presets (`day`, `week`) have weekend columns to fold;
+     * at `month` and coarser a tick is never wholly non-working, so this is
+     * ignored rather than shrinking a week by part of itself.
+     */
+    collapseWeekends?: boolean;
+    /** Width (px) of one folded run's marker. Default 12; `0` removes it outright. */
+    collapsedGapPx?: number;
+    /**
+     * Field naming the resource (person, crew, machine) a task is assigned to,
+     * plus the ordered resource list. Shown in the tooltip and, with
+     * `resourceHistogram`, summed into a load strip under the chart. Omit
+     * `resources` and the strip's rows come from the data, in first-seen order.
+     */
+    resourceField?: keyof TData & string;
+    resources?: ReadonlyArray<SchedulerResource>;
+    /**
+     * Show a per-resource load histogram below the chart: one row per resource,
+     * one bar per axis column, counting the tasks that touch it, with anything
+     * past capacity in red. `true` uses the defaults (capacity 1, 88px tall);
+     * the object form names a field on each {@link SchedulerResource} holding its
+     * capacity, and the strip's total height in px.
+     */
+    resourceHistogram?: boolean | {
+        capacityField?: string;
+        height?: number;
+    };
+};

package/dist/gantt/gantt-config.js

@@ -0,0 +1 @@
+export {};

package/dist/gantt/gantt-critical-path.d.ts

@@ -0,0 +1,67 @@
+/**
+ * gantt-critical-path - the critical path method (CPM) over a Gantt's tasks and
+ * their dependency links. Pure and framework-free, like every model in this
+ * package: a map of task times in, slack and the critical set out.
+ *
+ * Two passes over the dependency graph in topological order:
+ *
+ *   - **Forward** gives each task its EARLIEST start and finish: the later of
+ *     its own start and whatever its predecessors allow.
+ *   - **Backward** gives each task its LATEST start and finish: the earliest of
+ *     the project finish and whatever its successors need.
+ *
+ * `slack` is the gap between the two. A task with none cannot slip by a day
+ * without moving the project's finish, and the chain of those tasks is the
+ * critical path.
+ *
+ * Two rules worth stating, because both are judgement calls rather than
+ * arithmetic:
+ *
+ *  1. **An unlinked task is never critical.** A task in no dependency at all
+ *     is not on any path, so calling it critical would point at something the
+ *     schedule does not actually depend on. It still gets a slack figure - the
+ *     room it has before the project finish - for a Slack column to show.
+ *  2. **Cyclic links are ignored**, exactly as `cascade` ignores them: a cycle
+ *     has no legal schedule, so there is no earliest or latest to compute
+ *     through it.
+ *
+ * With a {@link WorkingCalendar} the passes run in WORKING time: a task's
+ * length is its working days, a latest start is counted back over working
+ * days, and slack is the working days a task could slip. Without one they
+ * run in calendar time, which is what a plan with no weekends is. The
+ * difference is not cosmetic: a five-day task ending Friday whose successor
+ * starts Monday has two calendar days of slack and none at all in working
+ * time - it is critical, and only the working-time pass says so.
+ *
+ * Nothing here reads the clock.
+ */
+import { type EventTimes, type SchedulerDependency } from '../scheduler-dependencies.js';
+import { type WorkingCalendar } from './gantt-model.js';
+export type CpmResult = {
+    /** Keys with no slack, and at least one link. See rule 1 in the header. */
+    critical: Set<string>;
+    /** Room each task has before it would move the project finish, in calendar ms. */
+    slackMs: Map<string, number>;
+    /**
+     * The same room in whole days: WORKING days when the pass was given a
+     * calendar, calendar days otherwise. The number a Slack column shows.
+     */
+    slackDays: Map<string, number>;
+    earliest: Map<string, EventTimes>;
+    latest: Map<string, EventTimes>;
+    /** The earliest the whole project can finish. */
+    finish: Date;
+};
+/**
+ * Run the two passes. `times` is every task the plan draws, keyed by row key -
+ * for a parent, pass the span its summary bar shows, so a link to a phase means
+ * "after the whole phase" without any special case here. Give `cal` for a
+ * working-time pass (see the header); omit it for calendar time.
+ */
+export declare function criticalPath(times: ReadonlyMap<string, EventTimes>, deps: ReadonlyArray<SchedulerDependency>, cal?: WorkingCalendar): CpmResult;
+/**
+ * A task's slack in whole days, for a table column: working days when the
+ * pass ran with a calendar, calendar days otherwise. Rounds toward zero, so
+ * "2" means two full days of room rather than anything up to three.
+ */
+export declare function slackDays(result: CpmResult, key: string): number;

package/dist/gantt/gantt-critical-path.js

@@ -0,0 +1,207 @@
+/**
+ * gantt-critical-path - the critical path method (CPM) over a Gantt's tasks and
+ * their dependency links. Pure and framework-free, like every model in this
+ * package: a map of task times in, slack and the critical set out.
+ *
+ * Two passes over the dependency graph in topological order:
+ *
+ *   - **Forward** gives each task its EARLIEST start and finish: the later of
+ *     its own start and whatever its predecessors allow.
+ *   - **Backward** gives each task its LATEST start and finish: the earliest of
+ *     the project finish and whatever its successors need.
+ *
+ * `slack` is the gap between the two. A task with none cannot slip by a day
+ * without moving the project's finish, and the chain of those tasks is the
+ * critical path.
+ *
+ * Two rules worth stating, because both are judgement calls rather than
+ * arithmetic:
+ *
+ *  1. **An unlinked task is never critical.** A task in no dependency at all
+ *     is not on any path, so calling it critical would point at something the
+ *     schedule does not actually depend on. It still gets a slack figure - the
+ *     room it has before the project finish - for a Slack column to show.
+ *  2. **Cyclic links are ignored**, exactly as `cascade` ignores them: a cycle
+ *     has no legal schedule, so there is no earliest or latest to compute
+ *     through it.
+ *
+ * With a {@link WorkingCalendar} the passes run in WORKING time: a task's
+ * length is its working days, a latest start is counted back over working
+ * days, and slack is the working days a task could slip. Without one they
+ * run in calendar time, which is what a plan with no weekends is. The
+ * difference is not cosmetic: a five-day task ending Friday whose successor
+ * starts Monday has two calendar days of slack and none at all in working
+ * time - it is critical, and only the working-time pass says so.
+ *
+ * Nothing here reads the clock.
+ */
+import { buildDependencyGraph, requiredStart, topoOrder, } from '../scheduler-dependencies.js';
+import { moveWorkingSpan, snapToWorkingDay, startForWorkingDays, workingDays, } from './gantt-model.js';
+const MS_MIN = 60000;
+const MS_DAY = 86400000;
+/** Below this, a slack is rounding noise rather than real room. */
+const CRITICAL_EPS_MS = MS_MIN;
+const durMs = (t) => Math.max(0, t.end.getTime() - t.start.getTime());
+const calendarArith = {
+    reqStart: (pred, dep, self) => requiredStart(pred, dep, durMs(self)),
+    capFinish: (succ, dep, self) => latestPredecessorFinish(succ, dep, durMs(self)),
+    endOf: (start, self) => new Date(start.getTime() + durMs(self)),
+    startOf: (end, self) => new Date(end.getTime() - durMs(self)),
+    slackDays: (es, ls) => Math.trunc((ls.getTime() - es.getTime()) / MS_DAY),
+    isCritical: (es, ls) => ls.getTime() - es.getTime() < CRITICAL_EPS_MS,
+};
+function workingArith(cal) {
+    const endOf = (start, self) => moveWorkingSpan(start, self, cal).end;
+    const startOf = (end, self) => {
+        const days = workingDays(self.start, self.end, cal);
+        return days > 0 ? startForWorkingDays(end, days, cal) : new Date(end.getTime() - durMs(self));
+    };
+    const lagOf = (dep) => (dep.lag ?? 0) * MS_MIN;
+    const snap = (d) => snapToWorkingDay(d, 1, cal);
+    return {
+        // What a link asks of the successor, landed on a working day - the same
+        // snap the cascade applies to a pushed task.
+        reqStart: (pred, dep, self) => {
+            const lag = lagOf(dep);
+            switch (dep.type ?? 'FS') {
+                case 'FS': return snap(new Date(pred.end.getTime() + lag));
+                case 'SS': return snap(new Date(pred.start.getTime() + lag));
+                case 'FF': return snap(startOf(new Date(pred.end.getTime() + lag), self));
+                case 'SF': return snap(startOf(new Date(pred.start.getTime() + lag), self));
+            }
+        },
+        // What a link allows of the predecessor's finish. An end that lands after
+        // a weekend is fine as it is: counting the start back over working days
+        // skips the weekend, so nothing has to be snapped here.
+        capFinish: (succ, dep, self) => {
+            const lag = lagOf(dep);
+            switch (dep.type ?? 'FS') {
+                case 'FS': return new Date(succ.start.getTime() - lag);
+                case 'SS': return endOf(new Date(succ.start.getTime() - lag), self);
+                case 'FF': return new Date(succ.end.getTime() - lag);
+                case 'SF': return endOf(new Date(succ.end.getTime() - lag), self);
+            }
+        },
+        endOf,
+        startOf,
+        slackDays: (es, ls) => (ls.getTime() > es.getTime() ? workingDays(es, ls, cal) : 0),
+        // No working day between the earliest and latest start: it cannot slip.
+        isCritical: (es, ls) => ls.getTime() <= es.getTime() || workingDays(es, ls, cal) === 0,
+    };
+}
+/**
+ * The LATEST finish a predecessor may have, given what its successor's latest
+ * times allow. The mirror of {@link requiredStart}, which answers the same
+ * question forwards.
+ */
+function latestPredecessorFinish(succLatest, dep, predDurationMs) {
+    const lagMs = (dep.lag ?? 0) * MS_MIN;
+    switch (dep.type ?? 'FS') {
+        // succ.start >= pred.end + lag  ->  pred.end <= succ.start - lag
+        case 'FS':
+            return new Date(succLatest.start.getTime() - lagMs);
+        // succ.start >= pred.start + lag  ->  pred.start <= succ.start - lag
+        case 'SS':
+            return new Date(succLatest.start.getTime() - lagMs + predDurationMs);
+        // succ.end >= pred.end + lag  ->  pred.end <= succ.end - lag
+        case 'FF':
+            return new Date(succLatest.end.getTime() - lagMs);
+        // succ.end >= pred.start + lag  ->  pred.start <= succ.end - lag
+        case 'SF':
+            return new Date(succLatest.end.getTime() - lagMs + predDurationMs);
+    }
+}
+/**
+ * Run the two passes. `times` is every task the plan draws, keyed by row key -
+ * for a parent, pass the span its summary bar shows, so a link to a phase means
+ * "after the whole phase" without any special case here. Give `cal` for a
+ * working-time pass (see the header); omit it for calendar time.
+ */
+export function criticalPath(times, deps, cal) {
+    const arith = cal ? workingArith(cal) : calendarArith;
+    const graph = buildDependencyGraph(deps);
+    const { order, cyclicIds } = topoOrder(graph);
+    const live = graph.deps.filter((d) => !cyclicIds.has(d.id));
+    /** Keys that take part in at least one usable link. */
+    const linked = new Set();
+    for (const d of live) {
+        if (times.has(d.from) && times.has(d.to)) {
+            linked.add(d.from);
+            linked.add(d.to);
+        }
+    }
+    // --- forward: earliest start / finish ------------------------------------
+    const earliest = new Map();
+    for (const [k, t] of times)
+        earliest.set(k, { start: t.start, end: t.end });
+    // Only the graph's nodes need relaxing, and only in topological order; a key
+    // outside the graph keeps its own dates.
+    for (const key of order) {
+        const self = times.get(key);
+        if (!self)
+            continue;
+        let es = self.start;
+        for (const dep of graph.pred.get(key) ?? []) {
+            if (cyclicIds.has(dep.id))
+                continue;
+            const pred = earliest.get(dep.from);
+            if (!pred)
+                continue;
+            const req = arith.reqStart(pred, dep, self);
+            if (req.getTime() > es.getTime())
+                es = req;
+        }
+        earliest.set(key, { start: es, end: arith.endOf(es, self) });
+    }
+    // The project finishes when its last task does.
+    let finishMs = -Infinity;
+    for (const t of earliest.values())
+        finishMs = Math.max(finishMs, t.end.getTime());
+    if (!Number.isFinite(finishMs))
+        finishMs = 0;
+    const finish = new Date(finishMs);
+    // --- backward: latest start / finish --------------------------------------
+    const latest = new Map();
+    for (const [k, self] of times) {
+        latest.set(k, { start: arith.startOf(finish, self), end: finish });
+    }
+    for (let i = order.length - 1; i >= 0; i--) {
+        const key = order[i];
+        const self = times.get(key);
+        if (!self)
+            continue;
+        let lf = finish;
+        for (const dep of graph.succ.get(key) ?? []) {
+            if (cyclicIds.has(dep.id))
+                continue;
+            const succ = latest.get(dep.to);
+            if (!succ)
+                continue;
+            const cap = arith.capFinish(succ, dep, self);
+            if (cap.getTime() < lf.getTime())
+                lf = cap;
+        }
+        latest.set(key, { start: arith.startOf(lf, self), end: lf });
+    }
+    // --- slack ----------------------------------------------------------------
+    const slackMs = new Map();
+    const slackDaysOf = new Map();
+    const critical = new Set();
+    for (const [k] of times) {
+        const e = earliest.get(k);
+        const l = latest.get(k);
+        slackMs.set(k, l.start.getTime() - e.start.getTime());
+        slackDaysOf.set(k, arith.slackDays(e.start, l.start));
+        if (linked.has(k) && arith.isCritical(e.start, l.start))
+            critical.add(k);
+    }
+    return { critical, slackMs, slackDays: slackDaysOf, earliest, latest, finish };
+}
+/**
+ * A task's slack in whole days, for a table column: working days when the
+ * pass ran with a calendar, calendar days otherwise. Rounds toward zero, so
+ * "2" means two full days of room rather than anything up to three.
+ */
+export function slackDays(result, key) {
+    return result.slackDays.get(key) ?? 0;
+}

package/dist/gantt/gantt-model.d.ts

@@ -0,0 +1,257 @@
+/**
+ * gantt-model - the pure, framework-free core behind the Gantt view. No Svelte,
+ * no DOM: rows in, resolved tasks / a work-breakdown tree / an axis out, so
+ * every rule here is unit-tested directly (mirrors scheduler-model.ts in
+ * @svgrid/grid).
+ *
+ * Three conventions this file owns, because getting them wrong is silent:
+ *
+ *  1. **Days are LOCAL.** A date-only string (`'2026-09-14'`) is parsed as
+ *     local midnight, not UTC. `new Date('2026-09-14')` is UTC midnight, which
+ *     in any negative-offset zone is the 13th locally - a bar a day early, on
+ *     every task, visible only to people west of Greenwich.
+ *  2. **`end` is exclusive, except a date-only string is inclusive of its day.**
+ *     A task from the 14th to the 16th is three days long, which is what every
+ *     planning tool means and what a person typing those dates expects. A
+ *     value carrying a time (a `Date`, epoch-ms, or an ISO string with `T`) is
+ *     taken literally.
+ *  3. **Duration counts WORKING days.** A 3-day task starting Friday ends
+ *     Wednesday, not Monday.
+ *
+ * Nothing here reads the clock: `projectRange` and `ganttAxis` take `today` as
+ * an argument so their output is testable without wall-clock flakiness.
+ */
+import type { DateLike, GanttZoom, TimelineAxis } from '@svgrid/grid';
+/** A new Date at local midnight of the same calendar day. */
+export declare function startOfDay(d: Date): Date;
+/** `n` days after `d` (negative to go back), preserving the time of day. */
+export declare function addDays(d: Date, n: number): Date;
+/**
+ * Parse a task date. A bare `YYYY-MM-DD` becomes LOCAL midnight of that day
+ * (see the header); anything else goes through the grid's `toDate`.
+ */
+export declare function parseDay(value: DateLike | null | undefined): Date | null;
+/** Which days are off: weekdays by number, plus specific dates. */
+export type WorkingCalendar = {
+    /** Weekday numbers, 0 = Sun .. 6 = Sat. */
+    nonWorkingDays: ReadonlyArray<number>;
+    /** `startOfDay(date).getTime()` for each holiday. */
+    holidays: ReadonlySet<number>;
+};
+/** Build a {@link WorkingCalendar}. Weekends (`[0, 6]`) are the default. */
+export declare function makeCalendar(nonWorkingDays?: ReadonlyArray<number>, holidays?: ReadonlyArray<DateLike>): WorkingCalendar;
+/** True when work happens on `d`'s calendar day. */
+export declare function isWorkingDay(d: Date, cal: WorkingCalendar): boolean;
+/**
+ * Working days in `[start, end)`. A task from Monday to the following Monday
+ * with weekends off is 5. Returns 0 when the range is empty or inverted.
+ */
+export declare function workingDays(start: Date, end: Date, cal: WorkingCalendar): number;
+/**
+ * The exclusive end of a task that starts on `start` and lasts `days` WORKING
+ * days: the midnight after its last working day. A zero or negative length
+ * gives `start` back (a milestone).
+ */
+export declare function addWorkingDays(start: Date, days: number, cal: WorkingCalendar): Date;
+/**
+ * The start of a task that lasts `days` WORKING days and ends (exclusively) at
+ * `end`: the inverse of {@link addWorkingDays}. Walks back from the day before
+ * `end` counting working days, so a five-day task ending Saturday 00:00
+ * started the Monday before. Zero days gives `end`'s own midnight.
+ */
+export declare function startForWorkingDays(end: Date, days: number, cal: WorkingCalendar): Date;
+/**
+ * The span a task keeps when it is moved to `start`: its WORKING days laid
+ * out from there, so a Monday-to-Friday task dragged to Wednesday ends the
+ * Tuesday after, not the Sunday. A task with no working day in it (a
+ * milestone, or one parked on a weekend) keeps its calendar length instead,
+ * so nothing collapses to zero.
+ */
+export declare function moveWorkingSpan(start: Date, original: {
+    start: Date;
+    end: Date;
+}, cal: WorkingCalendar): {
+    start: Date;
+    end: Date;
+};
+/**
+ * The nearest working day at or after `d` (`dir` 1) or at or before it
+ * (`dir` -1), at local midnight. A calendar with no working day at all returns
+ * `d`'s own midnight rather than spinning.
+ */
+export declare function snapToWorkingDay(d: Date, dir: 1 | -1, cal: WorkingCalendar): Date;
+/**
+ * Field accessors the model uses to read a task off a row. The renderer builds
+ * this from `GanttConfig`, applying its drag overlay first so a dragged bar
+ * resolves at its new dates without mutating the source row.
+ */
+export type GanttTaskSpec<TData> = {
+    getKey: (row: TData) => string;
+    getStart: (row: TData) => DateLike | null | undefined;
+    getEnd?: (row: TData) => DateLike | null | undefined;
+    /** Length in WORKING days, used when `getEnd` yields nothing. */
+    getDuration?: (row: TData) => number | null | undefined;
+    getTitle?: (row: TData) => string;
+    getProgress?: (row: TData) => number | null | undefined;
+    getParent?: (row: TData) => string | null | undefined;
+    getMilestone?: (row: TData) => boolean;
+    getColor?: (row: TData) => string | undefined;
+};
+/** One row resolved to a bar: local-midnight dates, `end` exclusive. */
+export type ResolvedTask<TData = unknown> = {
+    key: string;
+    row: TData;
+    title: string;
+    start: Date;
+    /** Exclusive. Equal to `start` for a milestone. */
+    end: Date;
+    /** 0-100, clamped. */
+    progress: number;
+    milestone: boolean;
+    parentKey: string | null;
+    color?: string;
+};
+/**
+ * Resolve `rows` into bars. A row with no readable start is SKIPPED - a
+ * backlog item with no date is not a bar, and dropping it is better than
+ * inventing a date for it.
+ *
+ * End wins over duration; duration counts working days from the start; with
+ * neither the task is a milestone (`end === start`). A date-only end string is
+ * inclusive of its day (see the file header).
+ */
+export declare function resolveTasks<TData>(rows: ReadonlyArray<TData>, spec: GanttTaskSpec<TData>, cal: WorkingCalendar): ResolvedTask<TData>[];
+/** One row of the Gantt, in display order. */
+export type GanttNode<TData = unknown> = {
+    task: ResolvedTask<TData>;
+    /** 0 for a root. */
+    depth: number;
+    hasChildren: boolean;
+    collapsed: boolean;
+    /**
+     * Present only on a parent: the span and percent rolled up from EVERY
+     * descendant, collapsed ones included.
+     */
+    summary?: {
+        start: Date;
+        end: Date;
+        progress: number;
+    };
+};
+/**
+ * Order tasks as a work-breakdown tree: roots in input order, each parent's
+ * children directly under it in input order. Rows whose parent id matches no
+ * task become roots rather than vanishing - the same rule the grid's tree data
+ * uses for a missing parent, and the one that keeps a filtered-out phase from
+ * hiding its tasks.
+ *
+ * Descendants of a collapsed node are left out of the returned list but still
+ * feed that node's summary, which is why this walks the full task set rather
+ * than the visible rows.
+ *
+ * A cycle in the parent links (a -> b -> a) is broken at the first repeat and
+ * the rows involved are treated as roots, so bad data cannot hang the render.
+ *
+ * Summary progress is the duration-weighted mean of the LEAF descendants: a
+ * two-day task at 100% beside a six-day task at 0% is 25% done, not 50%. A
+ * milestone weighs nothing (it has no duration), so a parent holding only
+ * milestones falls back to their plain mean.
+ */
+export declare function ganttTree<TData>(tasks: ReadonlyArray<ResolvedTask<TData>>, collapsed?: ReadonlySet<string>): GanttNode<TData>[];
+/** Each visible node's row index, for arrow geometry. */
+export declare function nodeIndex<TData>(nodes: ReadonlyArray<GanttNode<TData>>): Map<string, number>;
+/**
+ * Map every task key to the key of the visible row that stands for it: itself
+ * when it is on screen, else its nearest visible ancestor. A dependency
+ * pointing into a collapsed phase draws to that phase's summary bar instead of
+ * vanishing. Keys with no visible ancestor are left out.
+ */
+export declare function visibleAnchor<TData>(nodes: ReadonlyArray<GanttNode<TData>>, tasks: ReadonlyArray<ResolvedTask<TData>>): Map<string, string>;
+/**
+ * The date window the chart spans: the earliest start to the latest end, plus
+ * `paddingDays` of slack each side, clamped to `minDate` / `maxDate`.
+ *
+ * Never returns an empty window: with no tasks it centres on `today`, so an
+ * empty plan still renders an axis rather than dividing by zero.
+ */
+export declare function projectRange(tasks: ReadonlyArray<ResolvedTask<unknown>>, opts: {
+    paddingDays: number;
+    today: Date;
+    minDate?: DateLike | null;
+    maxDate?: DateLike | null;
+}): {
+    start: Date;
+    end: Date;
+};
+/**
+ * Target pixel width of ONE tick per preset. The chart's total width is
+ * `ticks.length * ganttTickWidth[zoom]`; individual ticks keep their true
+ * proportion of the window (February is narrower than March), so bars and
+ * header cells always line up.
+ */
+export declare const ganttTickWidth: Record<GanttZoom, number>;
+/**
+ * Build the Gantt's two-row header over `[start, end)` for a zoom preset. The
+ * window is snapped OUT to whole tick boundaries so the ticks tile it exactly -
+ * a half-drawn first column is where a header and its bars start disagreeing.
+ *
+ * Returns the scheduler's {@link TimelineAxis} shape (percentages, not pixels)
+ * so the Gantt and the scheduler timeline share `timelineGeom` and the same
+ * header markup:
+ *
+ * ```
+ * day     ticks: days    majors: weeks     ("14 - 20 Sep")
+ * week    ticks: days    majors: months    ("September 2026")   <- the default
+ * month   ticks: weeks   majors: months
+ * quarter ticks: months  majors: quarters  ("Q3 2026")
+ * year    ticks: months  majors: years     ("2026")
+ * ```
+ */
+export declare function ganttAxis(start: Date, end: Date, zoom: GanttZoom, opts?: {
+    weekStartsOn?: number;
+    today?: Date | null;
+}): TimelineAxis;
+/**
+ * One run of the axis at a single density: either drawn at the chart's normal
+ * rate, or folded down to a fixed-width gap.
+ */
+export type GanttSegment = {
+    start: Date;
+    /** Exclusive, like every end in this file. */
+    end: Date;
+    /** Left edge of this run, in px from the chart's left. */
+    x: number;
+    /** How wide the run is drawn. */
+    px: number;
+    collapsed: boolean;
+};
+/**
+ * The chart's date <-> pixel mapping, and the one place either direction is
+ * computed. Uniform by default; piecewise once whole days are folded out.
+ */
+export type GanttScale = {
+    totalPx: number;
+    segments: GanttSegment[];
+    /** A date's x offset (px) in the chart body. */
+    xOf: (d: Date) => number;
+    /** The inverse: which date an x offset lands on. */
+    dateAt: (x: number) => Date;
+};
+/**
+ * Build the scale over `[start, end)`.
+ *
+ * With no `collapsed` predicate this is the plain linear mapping - one segment,
+ * `totalPx` exactly as asked - which is what every chart without the Pro axis
+ * uses. Pass one and each run of days it answers true for folds to `gapPx`
+ * instead of its real width, so a year of weekends stops eating two sevenths of
+ * the chart. Within a gap the mapping stays proportional, so a task that does
+ * run over a folded weekend still draws across it rather than collapsing to a
+ * line.
+ *
+ * `gapPx` of 0 removes the folded days outright: Friday's finish and Monday's
+ * start land on the same pixel.
+ */
+export declare function ganttScale(start: Date, end: Date, totalPx: number, opts?: {
+    collapsed?: ((day: Date) => boolean) | null;
+    gapPx?: number;
+}): GanttScale;