@cjlapao/ui-kit-vue 0.2.0 → 0.2.3

package/dist/types/common/gantt/drag.d.ts

@@ -0,0 +1,221 @@
+/**
+ * Gantt interaction math — pure. Converts pointer deltas into date/duration
+ * edits and computes dependency-arrow geometry.
+ *
+ * The framework layer (React/Vue) owns the pointer listeners; everything
+ * here is a function in, value out, which keeps the behaviour unit-testable
+ * without a DOM.
+ */
+import type { GanttBarGeometry, GanttLink, GanttLinkPath, GanttLinkPoint, GanttLinkType, GanttSnap, GanttTask, TrueColor } from "./types";
+export declare const MIN_TASK_MS = 3600000;
+export interface GanttDragState {
+    kind: "move" | "resize-start" | "resize-end" | "link" | "reorder" | "progress";
+    taskId: string;
+    /** Pointer x at drag start, in timeline space. */
+    startX: number;
+    /** Pointer y at drag start, in row-area space. */
+    startY: number;
+    /** The task's start/end at drag start, epoch ms. */
+    originStart: number;
+    originEnd: number;
+    /** Row keys the pointer is currently over (reorder preview). */
+    beforeKey?: string | null;
+    /** Live pointer position (timeline x / row-area y). */
+    x: number;
+    y: number;
+}
+/**
+ * Produce the edited start/end for a live drag. `deltaX` is in px, the
+ * pointer delta from the drag origin. `snap` quantises the result.
+ *
+ * - `move` shifts both edges.
+ * - `resize-start` moves the start edge, clamped to `end - MIN_TASK_MS`.
+ * - `resize-end` moves the end edge, clamped to `start + MIN_TASK_MS`.
+ */
+export declare function applyDragDates(state: Pick<GanttDragState, "kind" | "originStart" | "originEnd">, deltaX: number, pxPerDay: number, snap: GanttSnap): {
+    start: number;
+    end: number;
+};
+/**
+ * Commit a drag onto a task: returns the edited task with ISO dates (or the
+ * same task when the edit is a no-op).
+ */
+export declare function commitDragEdit(task: GanttTask, startMs: number, endMs: number): GanttTask;
+/** Live progress (0..1) while dragging a progress knob. */
+export declare function progressFromPointer(pointerX: number, barLeft: number, barWidth: number): number;
+/** Radius of the port (connection node) drawn at each bar edge. */
+export declare const LINK_PORT_R = 3.5;
+/**
+ * The one uniform margin (px) a connector keeps whenever it passes by a bar:
+ * every vertical run hugs the nearest bar edge it passes at exactly this
+ * distance (and stays at least this far from the source/target bars it
+ * departs or enters). A single constant for obstacle avoidance *and* the
+ * shared-column alignment pass, so "passing a bar" always reads as the same
+ * padding everywhere in the diagram.
+ */
+export declare const LINK_PASS_PADDING = 6;
+/** How far left of the target's left edge the final corner must sit, so the
+ *  rounded elbow *and* the arrowhead both sit on a straight approach:
+ *  corner room + port clearance + arrowhead length + margin. */
+export declare const LINK_ENTRY_CLEAR: number;
+/** A 2D point in timeline pixel space (x, y). */
+export type GanttPt = [number, number];
+type Pt = GanttPt;
+/**
+ * Compute the SVG path, arrowhead and port anchors for a dependency link.
+ *
+ * Port convention (agreed): the connector always leaves the **source's right
+ * edge** (its "children" side — the successors it leads to) and enters the
+ * **target's left edge** (its "parents" side — the predecessors it depends on).
+ * So every dependency reads "item 1's right → item 2's left", and the link
+ * type (`fs`/`ff`/`ss`/`sf`) is conveyed by the line style (dashed for
+ * `ff`/`sf`) and the tooltip rather than by which edge is used.
+ *
+ * Routing is a best-path orthogonal route that never crosses a bar:
+ * - **Same row** — a straight connector between the two ports.
+ * - **Target to the right** — a vertical channel in the horizontal gap
+ *   between the bars, in a column no intermediate bar occupies.
+ * - **Overlapping / "going back"** — the connector steps out of the source
+ *   row into the clear row-boundary band, drops in a clear column, and
+ *   enters the target's left edge.
+ * - **No clear column** — the route swings out to the right of every bar in
+ *   the corridor, drops to the target row's clear band, and enters the port.
+ *
+ * `obstacles` are the bars (other than the source and target) the connector
+ * must not cross. `fanSrcY` / `fanTgtY` offset the port vertically so several
+ * links sharing a bar fan out instead of stacking. `points` are the corner
+ * points of the route (pre-rounding), exposed for the global alignment pass.
+ */
+export declare function linkPath(from: GanttBarGeometry, to: GanttBarGeometry, type: GanttLinkType, fanSrcY?: number, fanTgtY?: number, obstacles?: GanttBarGeometry[]): {
+    d: string;
+    points: Pt[];
+    arrow?: string;
+    from: GanttLinkPoint;
+    to: GanttLinkPoint;
+};
+/** Max spacing (px) between adjacent ports of links sharing a bar edge. */
+export declare const LINK_FAN_MAX_SPREAD = 16;
+/** Min distance (px) from a port to the bar's top/bottom edge. */
+export declare const LINK_FAN_INSET = 4;
+/** How far past the bar's half height the hover handle may float (into the
+ *  row's padding) so it can keep the fan's spacing from an occupied port. */
+export declare const LINK_HANDLE_OVERHANG = 4;
+/** Blank right gutter (px) past the timeline, so rightmost link routes and
+ *  their arrowheads never sit at the scroll edge. */
+export declare const LINK_RIGHT_GUTTER = 24;
+/** Per-bar port slots: `out` = outgoing ports on the right edge, `inc` =
+ *  incoming ports on the left edge, both as dense arrays of offsets from the
+ *  bar's centre, in slot order (top → bottom). */
+export interface GanttLinkFanOffsets {
+    out: number[];
+    inc: number[];
+}
+/** Result of {@link computeLinkFanOffsets}: dense per-bar slots for the hover
+ *  handles, plus the per-link lookup the path router uses. */
+export interface GanttLinkFanResult {
+    bars: Map<string, GanttLinkFanOffsets>;
+    /** One entry per input link (same order as `links`): the offset its source
+     *  edge and target edge ports sit at. Links whose bars are missing get 0. */
+    perLink: {
+        src: number;
+        tgt: number;
+    }[];
+}
+/**
+ * Compute the vertical port slots for every bar edge.
+ *
+ * Links sharing a side are **ordered by the other endpoint's centre Y** (top
+ * to bottom) and assigned evenly spaced slots: with n > 1 the spacing is
+ * `min(LINK_FAN_MAX_SPREAD, (barH - 2·LINK_FAN_INSET) / (n - 1))`, so ports
+ * fan across the bar edge without leaving it; a single link stays centred.
+ * Ordering by the other endpoint keeps the fan from crossing at the ports.
+ */
+export declare function computeLinkFanOffsets(links: GanttLink[], bars: Map<string, GanttBarGeometry>): GanttLinkFanResult;
+/**
+ * Pick the slot a *new* connector's hover handle / rubber preview should use
+ * on a bar edge that already carries `taken` port offsets.
+ *
+ * The handle floats into the row's padding, so the slot range extends
+ * {@link LINK_HANDLE_OVERHANG} past the bar's half height. Placement by
+ * preference:
+ * 1. the bar centre, when no port sits within a visible gap;
+ * 2. otherwise `LINK_FAN_MAX_SPREAD` (the fan's own spacing) away from the
+ *    nearest port, pushed toward the bar's edge (top first) — so the handle
+ *    never sits on a port and reads with the same spacing the fan gives its
+ *    ports;
+ * 3. otherwise the centre of the largest free gap (a crowded side).
+ * `0` when the side is free.
+ */
+export declare function fanHandleOffset(barHeight: number, taken: number[]): number;
+/**
+ * Resolve all visible links into draw-ready paths. Links referencing missing
+ * bars are skipped (defensive — a removed task must not break the overlay).
+ *
+ * Links that share a source (fan-out) or a target (fan-in) take **ordered
+ * even slots** on the bar edge ({@link computeLinkFanOffsets}): sorted by the
+ * other endpoint's Y, evenly spaced and clamped to the bar, so ports never
+ * overlap and lines never cross at the ports. After every route is computed,
+ * a global pass aligns overlapping vertical channels into shared columns.
+ */
+export declare function computeLinkPaths(links: GanttLink[], bars: Map<string, GanttBarGeometry>, defaultColor: TrueColor): GanttLinkPath[];
+/**
+ * Compute the rubber-band preview path for a link being dragged from `source`
+ * toward a pointer at (px, py).
+ *
+ * - When `target` is supplied (the bar currently under the pointer), the
+ *   preview is the *exact* committed-connector path — the same best-path,
+ *   collision-free right→left route the arrow will take once dropped, so the
+ *   preview never crosses a bar.
+ * - When there is no target (dangling mid-drag), the preview runs from the
+ *   source's right port to the pointer, routed to clear the source bar and
+ *   every other bar: it descends/ascends in the clear column nearest the
+ *   pointer (stepping into the clear band on the pointer's side when the
+ *   pointer is to the left of the source's right edge).
+ *
+ * `obstacles` are the bars (other than the source and any snapped target) the
+ * preview must not cross — normally every other visible bar.
+ *
+ * Returns the same shape as {@link linkPath} so the layer can render the
+ * preview identically to a committed arrow (arrowhead + port nodes).
+ */
+export declare function rubberLinkPath(source: GanttBarGeometry, px: number, py: number, target?: GanttBarGeometry, obstacles?: GanttBarGeometry[], 
+/** Vertical slot the rubber band departs from on the source edge (the
+ *  hover-handle's {@link fanHandleOffset}), so the preview never starts on an
+ *  existing port. Defaults to the bar centre. */
+fromOffset?: number): {
+    d: string;
+    arrow?: string;
+    from: GanttLinkPoint;
+    to: GanttLinkPoint;
+};
+/**
+ * Anchor a link-creation drag: given the pointer position relative to a bar,
+ * return which edge the new link departs from (`"out"` = right edge, the
+ * common FS source side). Used to aim the rubber-band preview.
+ */
+export declare function linkSourceAnchor(bar: GanttBarGeometry, pointerX: number): {
+    x: number;
+    y: number;
+    side: 1 | -1;
+};
+/**
+ * Pick radius (px) for selecting a dependency: the pointer selects the
+ * nearest link whose route passes within this many px of it. The visible
+ * stroke is ~1.5px wide, so without this, grabbing an arrow would demand
+ * pixel-perfect aiming.
+ */
+export declare const LINK_HIT_RADIUS = 6;
+/** Perpendicular distance from (x, y) to a polyline (Infinity when empty). */
+export declare function linkDistance(points: readonly GanttPt[], x: number, y: number): number;
+/**
+ * The link the pointer at (x, y) is aiming at: the nearest route within
+ * {@link LINK_HIT_RADIUS}. When two connectors run close together the closer
+ * one wins (exact ties go to the earlier link), so a generous radius never
+ * makes neighbouring arrows ambiguous.
+ */
+export declare function pickLinkAt(paths: readonly GanttLinkPath[], x: number, y: number, radius?: number): GanttLinkPath | null;
+/** Today marker x for a `today` date within the view. */
+export declare function todayX(today: number, viewStart: number, pxPerDay: number): number;
+/** Convenience: duration label from a drag state's live dates. */
+export declare function dragDurationLabel(start: number, end: number): string;
+export {};

package/dist/types/common/gantt/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Gantt — framework-agnostic core (types, time engine, layout, interaction
+ * math, tokens, sample data). The React and Vue kits wrap this engine with
+ * their own component layers; the engine itself has no framework imports.
+ */
+export * from "./types";
+export * from "./time";
+export * from "./layout";
+export * from "./drag";
+export * from "./tokens";
+export * from "./sample";

package/dist/types/common/gantt/layout.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Gantt row layout — pure. Flattens the task hierarchy into renderable rows,
+ * attaches lanes, computes row geometry and roll-up progress.
+ *
+ * Row order rules (top to bottom):
+ * 1. Tasks are grouped by `lane` (a task with no `lane` id goes to a
+ *    synthetic "default" lane, rendered without a band when no explicit
+ *    lanes were provided at all).
+ * 2. Within a lane, top-level tasks keep their input order (or the explicit
+ *    `rowOrder` when supplied); children are depth-first under their parent.
+ * 3. A lane or task with `open: false` collapses to its header row only.
+ */
+import type { GanttLane, GanttRow, GanttTask } from "./types";
+export declare const DEFAULT_ROW_HEIGHT = 44;
+export declare const GROUP_ROW_HEIGHT = 40;
+/** Roll-up of a task's descendants: duration-weighted, clamped to 0..1. */
+export declare function rollupProgress(task: GanttTask, tasksById: Map<string, GanttTask>, childrenByParent: Map<string, GanttTask[]>): number;
+/**
+ * Roll-up of the task identified by `taskId`: its own progress for a leaf,
+ * the duration-weighted roll-up of its descendants for a group (the value a
+ * group row displays — groups have no progress of their own). `override` is
+ * a preview edit of *any* task (usually the dragged child — live dates or
+ * live progress) substituted in place of that task's committed values before
+ * the roll-up is computed, which is what makes a group's percentage follow
+ * its child in real time while the child is being edited.
+ * Returns `null` when `taskId` is not in the list.
+ */
+export declare function taskRollupProgress(tasks: GanttTask[], taskId: string, override?: GanttTask): number | null;
+/**
+ * Duration-weighted progress over the lane that owns `taskId`, with
+ * `override` (a preview edit of that task — the live dates of an in-flight
+ * bar drag, or the live progress of a knob drag) substituted in place of
+ * the task's committed values. This is what lets a lane header recompute
+ * its roll-up in real time while one of its children is being edited.
+ * Returns `null` when `taskId` is not in the list.
+ */
+export declare function laneRollupProgress(tasks: GanttTask[], taskId: string, override?: GanttTask): {
+    laneId: string;
+    progress: number;
+} | null;
+/**
+ * Build the row model.
+ *
+ * @param tasks    The task list (parents may precede or follow children).
+ * @param lanes    Optional lane (swimlane) definitions; explicit lanes render
+ *                 even when empty (an empty band).
+ * @param rowOrder Optional explicit top-level order (task ids, per lane, in
+ *                 lane order). Ids not listed keep their input order and
+ *                 sort after the listed ones within their lane.
+ * @param rowHeight Row height in px.
+ */
+export declare function buildRows(tasks: GanttTask[], lanes?: GanttLane[], rowOrder?: string[], rowHeight?: number): {
+    rows: GanttRow[];
+    tasksById: Map<string, GanttTask>;
+    laneById: Map<string, GanttLane>;
+    laneOrder: string[];
+};
+/**
+ * Y (px, body-relative) of the reorder insertion indicator for the given
+ * displayed row order: the top edge of the row the dragged row is being
+ * inserted before, or — for an end drop — the bottom of the scope block
+ * (the parent's visible block for a child drag, the lane segment for a
+ * top-level drag). Pass the *previewed* row order while a live reorder is
+ * in flight so the indicator tracks the slot the dragged row currently
+ * occupies. Returns `null` when the dragged row can't be found.
+ */
+export declare function reorderPreviewTop(rows: GanttRow[], dragKey: string, beforeId: string | null): number | null;
+/**
+ * Apply a reorder drop to the dataset.
+ *
+ * - Top-level drag (`dragId` has no parent): `order` is the new per-lane
+ *   top-level id order for `buildRows`; `tasks` is the input array.
+ * - Child drag (`dragId` has a parent): the row moves among its *siblings*
+ *   (same parent). The top-level `order` is unchanged; `tasks` is a new flat
+ *   array with the dragged task repositioned relative to its siblings
+ *   (sibling order is the tasks-array order).
+ *
+ * `beforeId` is the top-level / sibling task id to insert before, or `null`
+ * for the end of the lane / sibling list. Returns the input references
+ * unchanged when the drop is a no-op (onto itself, across parents or lanes,
+ * or landing where the row already is).
+ */
+export interface RowReorderResult {
+    /** Per-lane top-level id order for `buildRows` (unchanged for child drags). */
+    order: string[];
+    /** Flat tasks array with the child-level move applied (the input array for
+     *  top-level drags and no-ops). */
+    tasks: GanttTask[];
+}
+export declare function applyRowReorder(tasks: GanttTask[], dragId: string, beforeId: string | null, currentOrder?: string[]): RowReorderResult;
+/**
+ * Resolve the reorder drop target for a live pointer position (`pointerY`
+ * in the row area's pixel space) — the same before/after system
+ * SmartGridLayout uses, evaluated against *blocks*: a row and its visible
+ * descendants form one unit, because a top-level drag can only address
+ * top-level rows and a child drag can only address its siblings.
+ *
+ * - Top-level drag: the candidate blocks are the other top-level subtrees
+ *   of the dragged lane.
+ * - Child drag: the candidate blocks are the sibling subtrees (same
+ *   parent).
+ *
+ * The pointer decides at the *block's* midpoint:
+ * - Above the midpoint → insert before the block.
+ * - Below the midpoint → insert after the block (i.e. before the next
+ *   block; `null` = end of the lane / sibling list).
+ * - Over the object being dragged (the dragged subtree's band) → the
+ *   previous target is kept. This is also the press itself: nothing shifts
+ *   until the pointer crosses into a neighbouring block, and the shift
+ *   happens once it has passed that block's midpoint — never "almost over
+ *   the second item".
+ * - Above the first block (the lane header band) → top of the lane; below
+ *   the last block → end of the lane.
+ *
+ * `currentBeforeId` is `undefined` before the first decision (right after
+ * the press) — no preview until the pointer commits. Because resolution
+ * runs against the *live preview* rows, a committed move parks the pointer
+ * over the dragged object's new band, where the target is kept — a stable
+ * fixed point, no oscillation.
+ */
+export declare function resolveDropBeforeId(rows: GanttRow[], tasksById: Map<string, GanttTask>, dragKey: string, pointerY: number, currentBeforeId?: string | null): {
+    beforeId: string | null | undefined;
+};
+/**
+ * The visible object being dragged for a reorder: the dragged row plus its
+ * visible descendant rows (contiguous in the live model — a single row for
+ * a leaf, the whole expanded block for an open group). `null` when the drag
+ * row can't be found. Used for the dashed ghost slot (its total height) and
+ * the floating clone (its stacked rows).
+ */
+export declare function reorderDragSubtree(rows: GanttRow[], dragKey: string): GanttRow[] | null;
+/** The top-level ancestor task id of a row (the row's task when top level). */
+export declare function topAncestorId(row: GanttRow, tasksById: Map<string, GanttTask>): string | null;

package/dist/types/common/gantt/sample.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Gantt sample project — a small product release with three swimlanes,
+ * hierarchy, milestones, dependencies and mixed colours. Dates are anchored
+ * to "today" so the demo always shows a live-looking plan around the
+ * today-marker.
+ */
+import type { GanttLane, GanttLink, GanttTask } from "./types";
+export declare const sampleGanttLanes: GanttLane[];
+export declare function sampleGanttTasks(now?: Date): GanttTask[];
+export declare function sampleGanttLinks(): GanttLink[];
+export declare const sampleGantt: {
+    lanes: GanttLane[];
+    tasks: typeof sampleGanttTasks;
+    links: typeof sampleGanttLinks;
+};

package/dist/types/common/gantt/time.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Gantt time engine — pure date/scale math, no framework imports.
+ *
+ * The timeline is a linear time→px projection: `x = (t - viewStart) *
+ * pxPerDay / MS_PER_DAY`. Header levels are generated from the real calendar
+ * (month columns have real widths, weeks start on the configured weekday), so
+ * labels never drift from the grid.
+ */
+import type { GanttDate, GanttSnap, GanttTimeScaleLevel } from "./types";
+export declare const MS_PER_DAY = 86400000;
+export declare const MS_PER_HOUR = 3600000;
+export declare const MS_PER_WEEK: number;
+/** Week starts Monday (0) … Sunday (6). Default 1 = Monday. */
+export declare const GANTT_WEEK_START = 1;
+export declare function toMs(value: GanttDate): number;
+export declare function msToIso(ms: number): string;
+/** Whole days between two ms values (fractional). */
+export declare function daysBetween(a: number, b: number): number;
+export declare function startOfDay(ms: number): number;
+export declare function addDays(ms: number, days: number): number;
+/** `weekday` 1 = Monday … 7 = Sunday, matching the ISO week (0 unused). */
+export declare function startOfWeek(ms: number, weekday?: number): number;
+export declare function startOfMonth(ms: number): number;
+export declare function startOfQuarter(ms: number): number;
+export declare function startOfYear(ms: number): number;
+export declare function endOfMonth(ms: number): number;
+/** Start of the month `months` from `ms` (negative supported). */
+export declare function addMonths(ms: number, months: number): number;
+type LabelLocale = string | undefined;
+export declare function formatDay(ms: number, locale?: LabelLocale): string;
+export declare function formatDayNumber(ms: number, locale?: LabelLocale): string;
+export declare function formatWeekday(ms: number, locale?: LabelLocale): string;
+export declare function formatMonth(ms: number, locale?: LabelLocale): string;
+export declare function formatMonthName(ms: number, locale?: LabelLocale): string;
+export declare function formatYear(ms: number, locale?: LabelLocale): string;
+export declare function formatQuarter(ms: number, _locale?: LabelLocale): string;
+export declare function formatDateTime(ms: number, locale?: LabelLocale): string;
+/** "3d" / "1d 4h" / "6h" — duration label for tooltips & cells. */
+export declare function formatDuration(startMs: number, endMs: number): string;
+/**
+ * Compute the timeline's visible range from the data: from the earliest
+ * start to the latest end, padded one week on each side so the outermost bar
+ * is not glued to the edge. Zoom-independent on purpose — the zoom handler
+ * anchors the date under the pointer, which is only exact when the range
+ * does not move between zoom steps.
+ */
+export declare function computeViewRange(starts: number[], ends: number[]): {
+    start: number;
+    end: number;
+};
+export declare function dateToX(ms: number, viewStart: number, pxPerDay: number): number;
+export declare function xToDate(x: number, viewStart: number, pxPerDay: number): number;
+/**
+ * Snap a timestamp to the configured unit. `week` snaps to the start of the
+ * week. `none` passes through (still clamped to the hour when the timeline is
+ * hour-fine, i.e. pxPerDay > 120).
+ */
+export declare function snapDate(ms: number, snap: GanttSnap): number;
+/**
+ * Pick the base header unit for a zoom. Two levels are produced: a coarse
+ * level (month/year/quarter) and a fine level whose columns are the grid
+ * lines of the timeline.
+ */
+export declare function pickBaseUnit(pxPerDay: number): "day" | "week" | "month" | "quarter";
+/**
+ * Build the two header levels for the visible range. Columns align to real
+ * calendar boundaries and carry their true widths (a February is narrower
+ * than a March).
+ */
+export declare function buildTimeScale(rangeStart: number, rangeEnd: number, pxPerDay: number, locale?: string): GanttTimeScaleLevel[];
+/** ISO-8601 week number (used for the week header label). */
+export declare function getIsoWeekNumber(ms: number): number;
+/**
+ * Width of the visible timeline in px.
+ */
+export declare function rangeWidth(rangeStart: number, rangeEnd: number, pxPerDay: number): number;
+export {};

package/dist/types/common/gantt/tokens.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Gantt colour tokens — TrueColor → Tailwind class maps.
+ *
+ * Every dynamic class produced here is emitted by
+ * `scripts/generate-safelist.mjs` (Gantt section), because the scanner only
+ * sees static strings. The dark: pairs keep the chart legible on both
+ * schemes without a single hand-edited hex.
+ */
+import type { TrueColor } from "../theme/Theme";
+export interface GanttBarTokens {
+    /** Bar fill (light + dark identical — saturated reads on both). Used for
+     *  the milestone diamond, owner initials and badges. */
+    fill: string;
+    /** Light base of a task bar — the un-done part of a bar reads as a soft
+     *  tint, so the darker progress fill stands out (done vs. remaining). */
+    base: string;
+    /** Base hover step. */
+    baseHover: string;
+    /** Progress overlay inside the bar (the done part, a step darker than the
+     *  base). */
+    progress: string;
+    /** Milestone diamond fill. */
+    milestone: string;
+    /** Bar border / 1px rim. */
+    rim: string;
+    /** Text on the bar. */
+    text: string;
+    /** Soft tint used for the row wash behind a task's bar. */
+    soft: string;
+    /** Soft tint, dark scheme. */
+    softDark: string;
+}
+export declare function getGanttBarTokens(color: TrueColor): GanttBarTokens;
+export interface GanttLaneTokens {
+    /** Lane band background. */
+    band: string;
+    /** Lane header label colour. */
+    label: string;
+    /** Accent edge of the lane header. */
+    accent: string;
+    /** Progress chip fill. */
+    chip: string;
+}
+export declare function getGanttLaneTokens(color: TrueColor): GanttLaneTokens;
+export interface GanttColumnTokens {
+    /** Header cell background. */
+    header: string;
+    /** Header text. */
+    text: string;
+    /** Cell divider. */
+    border: string;
+}
+export declare function getGanttColumnTokens(color: TrueColor): GanttColumnTokens;
+export interface GanttLinkTokens {
+    /** SVG stroke class for the arrow. */
+    stroke: string;
+    /** Arrow head / port-node fill. */
+    fill: string;
+    /** Pale halo behind a port node. */
+    halo: string;
+}
+export declare function getGanttLinkTokens(color: TrueColor): GanttLinkTokens;
+/** Today marker: the Gantt's accent colour. */
+export declare function getGanttTodayTokens(color: TrueColor): {
+    line: string;
+    chip: string;
+    text: string;
+};
+/** Selection ring for a focused/selected bar. */
+export declare function getGanttSelectionTokens(color: TrueColor): {
+    ring: string;
+    row: string;
+};