@jaeungkim/gantt-chart 0.3.1 → 0.4.0

package/dist/utils/grouping.d.ts

@@ -0,0 +1,81 @@
+import { GanttGroupBy } from '../types/gantt';
+import { TaskTransformed } from '../types/task';
+import { TaskTree } from '../core/tree';
+/** Prefix the collapsed-id set uses for a group header row */
+export declare const GROUP_ROW_PREFIX = "group:";
+/** Label a task with no group value falls into */
+export declare const DEFAULT_UNGROUPED_LABEL = "Ungrouped";
+export interface GanttRowGroup {
+    /** The raw value `groupBy` produced ("" for the ungrouped bucket) */
+    key: string;
+    /** What the header shows */
+    label: string;
+    /** How many tasks the group holds (rows can be fewer - lanes share a row) */
+    count: number;
+}
+/**
+ * One rendered row
+ *
+ * Normally one task, several when they share a `lane`, none when the row is a
+ * group header. The tree numbers (`level`/`posinset`/`setsize`) are the ARIA
+ * values for the row, so the render never has to work them out again.
+ */
+export interface GanttRow {
+    /** Stable key - the group id for a header, otherwise the ids on the row */
+    id: string;
+    tasks: TaskTransformed[];
+    /** Indentation level, 0-based */
+    depth: number;
+    /** `aria-level`, 1-based */
+    level: number;
+    /** `aria-posinset` among the rows that share a parent */
+    posinset: number;
+    /** `aria-setsize` for that same set */
+    setsize: number;
+    /** Set only on a group header row */
+    group?: GanttRowGroup;
+}
+export interface BuildGanttRowsOptions {
+    /** Field name or accessor deciding which group a task belongs to */
+    groupBy?: GanttGroupBy;
+    /** Collapsed group ids (task ids in the same set are ignored here - the tree filter handles those) */
+    collapsedIds?: ReadonlySet<string>;
+    /**
+     * The parentId tree (only when hierarchy is on)
+     *
+     * Given, a task's group is read off its root ancestor, so a subtree is never
+     * split across two groups.
+     */
+    tree?: TaskTree;
+    /** Header label for tasks whose group value is missing */
+    ungroupedLabel?: string;
+}
+/** The row id for a group key */
+export declare function groupRowId(key: string): string;
+/**
+ * Packs tasks that share a lane onto as few rows as possible
+ *
+ * Greedy interval partitioning: walking the tasks in start order, each one joins
+ * the first row whose last task has already ended, and opens a new row when
+ * every row is still busy. Non-overlapping tasks therefore end up side by side
+ * on one row, and an overlap stacks onto the next row instead of drawing two
+ * bars on top of each other.
+ */
+export declare function packLanes(tasks: TaskTransformed[]): TaskTransformed[][];
+/**
+ * The row model the chart renders
+ *
+ * With no `groupBy` and no task carrying a `lane` this is one row per task, in
+ * the order given - the behavior of a chart that sets neither.
+ *
+ * `groupBy` puts a header row in front of each group and indents its tasks by
+ * one level; with `tree` (hierarchy on) the group comes from a task's root
+ * ancestor, so grouping decides the top level and the parentId nesting is kept
+ * inside the group. A group listed in `collapsedIds` keeps its header and drops
+ * its rows.
+ *
+ * Every task's `order` is rewritten to its row number, so anything positioning
+ * by row - the dependency arrows above all - follows grouping and lane packing
+ * without knowing about either.
+ */
+export declare function buildGanttRows(tasks: TaskTransformed[], options?: BuildGanttRowsOptions): GanttRow[];

package/dist/utils/headerUtils.d.ts

@@ -0,0 +1,6 @@
+import { GanttTopHeaderGroup } from '../types/gantt';
+/**
+ * Merges consecutive groups that carry the same label
+ * Consecutive cells in the same month/year and so on become a single group
+ */
+export declare function mergeHeaderGroups(groups: GanttTopHeaderGroup[]): GanttTopHeaderGroup[];

package/dist/utils/history.d.ts

@@ -0,0 +1,56 @@
+import { Task } from '../types/task';
+/**
+ * Field values one task changed by, recorded per gesture.
+ *
+ * Only the keys that actually differ are stored, so a step costs a handful of
+ * strings rather than a copy of the task array.
+ */
+export interface TaskPatch {
+    id: string;
+    /** Values from before the gesture - what undo writes back */
+    before: Partial<Task>;
+    /** Values from after the gesture - what redo writes back */
+    after: Partial<Task>;
+}
+/** One user gesture. A subtree drag that moved 20 rows is still one entry. */
+export type HistoryEntry = TaskPatch[];
+export interface HistoryStack {
+    /** Oldest step first - the last one is what undo pops */
+    past: HistoryEntry[];
+    /** Steps undone and still redoable, newest first */
+    future: HistoryEntry[];
+}
+export declare const EMPTY_HISTORY: HistoryStack;
+/** How many steps are kept when no `historyLimit` is given */
+export declare const DEFAULT_HISTORY_LIMIT = 100;
+/**
+ * Builds the undo step for one gesture, or null when the change cannot be
+ * inverted by a field patch.
+ *
+ * Every gesture today rewrites fields on existing rows (`tasks.map(...)`), which
+ * is exactly what a patch can undo. A change that adds, removes or replaces a row
+ * returns null instead of a half-correct entry, and the caller drops the history
+ * rather than storing a step that would corrupt the data on replay.
+ */
+export declare function diffTasks(before: Task[], after: Task[]): HistoryEntry | null;
+/** Writes one direction of a step back onto the tasks it touched */
+export declare function applyPatches(tasks: Task[], entry: HistoryEntry, direction: 'before' | 'after'): Task[];
+/**
+ * Records a step.
+ *
+ * A gesture that changed nothing is not a step. A new action branches the
+ * timeline, so anything that was undone stops being redoable.
+ */
+export declare function pushHistory(stack: HistoryStack, entry: HistoryEntry, limit: number): HistoryStack;
+/** Applies a new depth to an existing stack, dropping the steps that no longer fit */
+export declare function limitHistory(stack: HistoryStack, limit: number): HistoryStack;
+/** Moves the newest step from past to future. null when there is nothing to undo. */
+export declare function popUndo(stack: HistoryStack): {
+    stack: HistoryStack;
+    entry: HistoryEntry;
+} | null;
+/** Moves the newest undone step back onto past. null when there is nothing to redo. */
+export declare function popRedo(stack: HistoryStack): {
+    stack: HistoryStack;
+    entry: HistoryEntry;
+} | null;

package/dist/utils/i18n.d.ts

@@ -0,0 +1,16 @@
+import { GanttFormatters, GanttLabelUnit, GanttLocaleOptions, GanttScaleKey } from '../types/gantt';
+/**
+ * Unit the top header row groups by
+ *
+ * A first day of the week is only meaningful where weeks are the grouping, which is the
+ * week scale - and there it is opt-in, so a chart that passes no `firstDayOfWeek` keeps
+ * grouping the week scale by month exactly as before.
+ */
+export declare function resolveLabelUnit(scale: GanttScaleKey, options?: GanttLocaleOptions): GanttLabelUnit;
+/**
+ * The tick/header/tooltip formatters for one scale
+ *
+ * Cheap enough to call per render, but it builds `Intl.DateTimeFormat` instances, so
+ * callers memoize it on [scale, options].
+ */
+export declare function resolveFormatters(scale: GanttScaleKey, options?: GanttLocaleOptions): GanttFormatters;

package/dist/utils/mutation.d.ts

@@ -0,0 +1,47 @@
+import { GanttBeforeChangeHandler, GanttChangeType, GanttTaskChange } from '../types/gantt';
+import { Task } from '../types/task';
+/** How long a rolled-back bar animates back - matches --gantt-transition-normal */
+export declare const REVERT_DURATION_MS = 200;
+/** What the caller should do once the before-handler has answered */
+export type MutationOutcome = 'commit' | 'rollback' | 'stale';
+/**
+ * The gate's key for a gesture
+ *
+ * Moves and resizes both rewrite the dates, so they share a lane and supersede each
+ * other; a progress edit runs in its own lane and leaves a pending date change alone.
+ */
+export declare function mutationKey(type: GanttChangeType, taskId: string): string;
+export interface BuildTaskChangeParams {
+    type: GanttChangeType;
+    /** The bar the user grabbed */
+    taskId: string;
+    /** Ids the gesture rewrites - more than one when a summary bar carries its subtree */
+    changedIds: string[];
+    /** The task array as it was before the gesture */
+    previous: Task[];
+    /** The task array the gesture wants to commit */
+    next: Task[];
+    edge?: 'start' | 'end';
+}
+/**
+ * Builds the payload handed to `onBeforeTaskChange`
+ *
+ * `changedTasks` and `previousTasks` line up index for index, so a host can diff the two
+ * without looking anything up.
+ */
+export declare function buildTaskChange({ type, taskId, changedIds, previous, next, edge, }: BuildTaskChangeParams): GanttTaskChange;
+/**
+ * Decides commit or rollback for gestures whose before-handler may still be in flight
+ *
+ * A gesture claims its lane on the first movement and settles once the handler answers.
+ * If another gesture claimed the same lane in between, this one lost the bar and its
+ * answer is dropped ('stale') - otherwise a slow veto would drag a bar the user has since
+ * moved somewhere else back to a position nobody asked for.
+ */
+export declare function createMutationGate(): {
+    /** Claims a lane and returns the token identifying this gesture */
+    begin(key: string): number;
+    /** Runs the handler and reports what the caller should do with the result */
+    settle(key: string, token: number, handler: GanttBeforeChangeHandler, change: GanttTaskChange): Promise<MutationOutcome>;
+};
+export type MutationGate = ReturnType<typeof createMutationGate>;

package/dist/utils/pngExport.d.ts

@@ -0,0 +1,67 @@
+import { Dayjs } from 'dayjs';
+import { GanttBottomRowCell, GanttScaleKey } from '../types/gantt';
+/** Date range the export is clipped to */
+export interface GanttExportRange {
+    from: string | Date | Dayjs;
+    to: string | Date | Dayjs;
+}
+/** Options for `GanttHandle.exportToPng` */
+export interface GanttExportOptions {
+    /**
+     * Pixel density of the output (default 2)
+     *
+     * Lowered automatically when the resulting canvas would exceed the browser's
+     * limits - a very wide timeline is downscaled rather than failing.
+     */
+    pixelRatio?: number;
+    /** Background colour (any CSS colour). Defaults to the resolved theme background. */
+    background?: string;
+    /**
+     * Clip the export to a date range
+     *
+     * Dates outside the timeline are clamped to its edges. Omit to export the
+     * whole timeline.
+     */
+    range?: GanttExportRange;
+}
+/**
+ * Largest scale factor that keeps the canvas inside the browser's limits
+ *
+ * Returns `pixelRatio` unchanged when it already fits. May return a value below
+ * 1 for a timeline that is wider than the maximum canvas on its own.
+ */
+export declare function resolveCanvasScale(width: number, height: number, pixelRatio: number, maxSide?: number, maxArea?: number): number;
+/**
+ * Resolves the export's horizontal window in px
+ *
+ * With no range, the whole timeline. Throws when the requested range does not
+ * overlap the timeline at all - an empty image is never what the caller wanted.
+ */
+export declare function resolveExportRangePx(range: GanttExportRange | undefined, cells: GanttBottomRowCell[], scale: GanttScaleKey, totalWidth: number): {
+    left: number;
+    width: number;
+};
+/** Wraps serialized XHTML in an SVG `foreignObject` and returns it as a data URL */
+export declare function toSvgDataUrl(markup: string, width: number, height: number): string;
+/** Waits one animation frame */
+export declare function nextFrame(): Promise<void>;
+export interface CaptureParams {
+    /** Left edge of the exported window, in timeline px */
+    left: number;
+    /** Width of the exported window, in timeline px */
+    width: number;
+    background: string;
+    pixelRatio: number;
+}
+/**
+ * Rasterizes the scroll container's full content to a PNG blob
+ *
+ * The chart is DOM, not canvas, so it is captured by cloning the subtree,
+ * inlining the computed styles it actually uses, and handing the result to the
+ * browser's own renderer through `<svg><foreignObject>`. The clone is never
+ * attached to the document, so the live chart is untouched.
+ *
+ * The caller is responsible for having every row, arrow and header cell
+ * rendered before this runs - a virtualized chart only holds the visible slice.
+ */
+export declare function captureScrollContainer(scrollEl: HTMLElement, { left, width, background, pixelRatio }: CaptureParams): Promise<Blob>;

package/dist/utils/pointerGesture.d.ts

@@ -0,0 +1,31 @@
+/** How long a finger has to rest on a bar before the drag lifts (ms) */
+export declare const TOUCH_LONG_PRESS_MS = 400;
+/** How far the finger may drift during that wait before the press is read as a scroll (px) */
+export declare const TOUCH_SLOP_PX = 10;
+export interface PointerGestureStart {
+    pointerType: string;
+    pointerId: number;
+    clientX: number;
+    clientY: number;
+}
+/**
+ * Starts a drag gesture the way the pointer that began it expects.
+ *
+ * A mouse press is unambiguous, so `onStart` runs immediately and nothing changes
+ * for existing behavior. Touch and pen have to be disambiguated from a scroll:
+ * `onStart` runs only once the pointer has stayed within `TOUCH_SLOP_PX` for
+ * `TOUCH_LONG_PRESS_MS`, so a swipe over a bar still scrolls the timeline and only
+ * a deliberate press lifts it.
+ *
+ * Returns the function that aborts a pending long press, or null when the gesture
+ * already started (a mouse, or nothing left to abort).
+ */
+export declare function armPointerGesture(start: PointerGestureStart, onStart: (clientX: number, clientY: number) => void, target?: EventTarget): (() => void) | null;
+/**
+ * Stops the browser from scrolling while a touch drag is running.
+ *
+ * `touch-action` is fixed when the gesture starts, and bars have to allow panning
+ * so a swipe can scroll - so once the long press lifts a bar, the scroll has to be
+ * suppressed here instead. The listener must be non-passive for that to work.
+ */
+export declare function suppressTouchScroll(target?: EventTarget): () => void;

package/dist/utils/rowDrag.d.ts

@@ -0,0 +1,69 @@
+import { Task } from '../types/task';
+import { TaskTree } from '../core/tree';
+/**
+ * Row reordering
+ *
+ * Row order comes from the dotted `sequence`, nesting from `parentId` - two independent
+ * sources. A drop only has to change `parentId`, but leaving `sequence` alone would put the
+ * row back where it was on the next sort. So a move renumbers `sequence` from the resulting
+ * tree: it becomes a derived value (position among siblings, prefixed by the parent's
+ * sequence) and the two sources can no longer disagree. That costs a new sequence on every
+ * row after the move, which is the price of the round-trip through `onTasksChange` landing
+ * where the user dropped it.
+ *
+ * Sibling order before a move still comes from `sequence`, so every tree here is built from
+ * the sequence-sorted array - `childIds` and `rootIds` are then in row order.
+ */
+/** A row as the resolver sees it - TaskTransformed fits as-is */
+export interface RowDropRow {
+    id: string;
+}
+export interface RowDropTarget {
+    /**
+     * `"line"` - an insertion line drawn at the top edge of row `rowIndex`
+     * (`rowIndex === rows.length` means below the last row).
+     * `"into"` - row `rowIndex` is highlighted and becomes the new parent.
+     */
+    mode: "line" | "into";
+    rowIndex: number;
+    /** Tree depth the dragged row lands at - how far the indicator is indented */
+    depth: number;
+    /** The new parent (null = root) */
+    parentId: string | null;
+    /** Position among the new parent's children, counted after the row is detached */
+    index: number;
+    /** false when the drop would put the row inside its own subtree - never committed */
+    valid: boolean;
+}
+export interface ResolveRowDropOptions {
+    draggedId: string;
+    /** Pointer Y measured from the top of the first row (px) */
+    offsetY: number;
+    /** Pointer X travel since the drag started (px) - positive indents, negative outdents */
+    deltaX: number;
+    /** Tree of the full task list, built from the sequence-sorted array */
+    tree: TaskTree;
+    /** The dragged subtree's ids - anything in here is an illegal parent */
+    blockedIds: Set<string>;
+    rowHeight?: number;
+    indentWidth?: number;
+}
+/**
+ * Where a pointer at (offsetY, deltaX) would drop the dragged row
+ *
+ * `rows` are the rows actually on screen (collapsed subtrees already filtered out), in row
+ * order. Returns null when the dragged row is not among them.
+ */
+export declare function resolveRowDropTarget(rows: RowDropRow[], options: ResolveRowDropOptions): RowDropTarget | null;
+/**
+ * The task array with `moveId` re-parented to `parentId` at `index` among its new siblings
+ *
+ * Every `sequence` is rewritten from the resulting tree, so the dotted string and the parent
+ * chain agree afterwards - the array survives a round-trip through `onTasksChange`.
+ * `parentId` is only ever written on the moved task; a task whose parent link is an orphan or
+ * a cycle keeps that link and is numbered as the root the tree already treats it as.
+ *
+ * Returns the input array unchanged when the move is unknown, illegal (the target is inside
+ * the moved subtree) or a no-op.
+ */
+export declare function moveTaskInTree(tasks: Task[], moveId: string, parentId: string | null, index: number): Task[];

package/dist/utils/timeline.d.ts

@@ -0,0 +1,161 @@
+import { Dayjs } from 'dayjs';
+import { GanttBottomRowCell, GanttDateRange, GanttDragBounds, GanttDragMode, GanttLocaleOptions, GanttMarker, GanttRangeBand, GanttRangeExtension, GanttScaleKey, GanttTopHeaderGroup, GanttVisibleRange } from '../types/gantt';
+import { Task, TaskTransformed } from '../types/task';
+export interface TimelineData {
+    bottomCells: GanttBottomRowCell[];
+    transformedTasks: TaskTransformed[];
+}
+export interface NonWorkingRange {
+    left: number;
+    width: number;
+}
+/**
+ * How far the timeline origin moved, in px - the scrollLeft compensation
+ *
+ * The timeline range comes from the tasks' min/max dates, so dragging the
+ * earliest task moves the origin as a whole and pushes every bar across the
+ * screen. Adding this value to scrollLeft keeps the date you were looking at
+ * in place.
+ *
+ * Positive when cells were added in front, negative when they were removed.
+ */
+export declare function originShiftPx(prevTicks: GanttBottomRowCell[], nextTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey): number;
+/**
+ * Merges non-working (weekend/holiday) cells into px ranges
+ * Only applies to scales whose tick unit is a day or finer
+ */
+export declare function computeNonWorkingRanges(timelineTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey, isNonWorkingDay: (date: Dayjs) => boolean): NonWorkingRange[];
+/**
+ * Moves a date by the given number of drag steps
+ *
+ * Adds the scale's drag unit (hour/day) as-is. Converting to minutes first
+ * (day = 1440 minutes) drifts by an hour at a local-calendar DST boundary,
+ * where a day is 23 or 25 hours, and tasks near midnight get committed to an
+ * entirely different date cell.
+ */
+export declare function shiftByDragSteps(date: Dayjs, steps: number, scaleKey: GanttScaleKey): Dayjs;
+/**
+ * Distance between two dates in px, at the scale's drag resolution
+ *
+ * The inverse of shiftByDragSteps: a date moved by N drag steps sits exactly
+ * N * basePxPerDragStep away. Fractional, so a date clamped part-way through a
+ * step still gets an exact px offset.
+ */
+export declare function pxBetweenDates(from: Dayjs, to: Dayjs, scaleKey: GanttScaleKey): number;
+/**
+ * Clamps a dragged bar into its allowed date window
+ *
+ * A drag that runs past a bound snaps to it instead of stopping short or
+ * jumping - the returned dates are what gets both previewed and committed.
+ *
+ * - `bar`: both ends move together, so the bar keeps its length. When the bar is
+ *   longer than the window itself the two bounds cannot both hold; `min` wins.
+ * - `left`/`right`: only the dragged edge moves, and the bar is kept at least one
+ *   drag step wide. That non-inversion guard is applied last, so a task whose
+ *   window has already been passed stays a valid bar rather than folding over.
+ *
+ * Returns the inputs untouched when no bound is set.
+ */
+export declare function clampDragDates(mode: GanttDragMode, startDate: Dayjs, endDate: Dayjs, bounds: GanttDragBounds, scaleKey: GanttScaleKey): {
+    startDate: Dayjs;
+    endDate: Dayjs;
+};
+/**
+ * Largest shared move that keeps every bar inside its own window
+ *
+ * Bars dragged as one group - a summary row and its subtree - have to move by a
+ * single delta or the group tears apart, so the group moves by the smallest
+ * magnitude any member allows. A descendant's own bounds therefore constrain the
+ * whole drag: no bar can be pushed out of its window by grabbing its parent.
+ *
+ * The result always lies between 0 and the requested delta, so a bar that is
+ * already outside its window simply refuses to move further, rather than yanking
+ * the group backwards against the drag.
+ */
+export declare function clampMoveDelta(members: {
+    start: Dayjs;
+    end: Dayjs;
+    bounds: GanttDragBounds;
+}[], requestedMs: number, scaleKey: GanttScaleKey): number;
+export declare function calculateDateOffsets(startDate: Dayjs, endDate: Dayjs, timelineTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey): {
+    barMarginLeftAmount: number;
+    barWidthSize: number;
+};
+/**
+ * Computes the px offset of a given date along the timeline
+ * Returns null when the date is outside the timeline range
+ */
+export declare function calculateDateOffsetPx(date: Dayjs, timelineTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey): number | null;
+/**
+ * Date sitting at a px offset along the timeline - the inverse of calculateDateOffsetPx
+ * Returns null when the offset falls outside the rendered range
+ *
+ * Used to remember what the cursor was pointing at before a zoom, so the same date can be
+ * put back under it afterwards.
+ */
+export declare function dateAtOffsetPx(offsetPx: number, timelineTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey): Dayjs | null;
+/** First and last moment the rendered ticks cover (null for an empty timeline) */
+export declare function timelineRange(timelineTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey): GanttDateRange | null;
+/** A marker placed on the timeline, with the overrun check already resolved */
+export interface PositionedMarker {
+    marker: GanttMarker;
+    leftPx: number;
+    /** A task covered by the marker ends past its date */
+    overrun: boolean;
+}
+/**
+ * Places markers on the timeline, dropping the ones outside the rendered range
+ *
+ * `warnOnOverrun` markers report whether a task ends past their date - every task, or
+ * only the ones named in `taskIds`.
+ */
+export declare function computeMarkerOffsets(markers: GanttMarker[], timelineTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey, tasks?: Pick<Task, "id" | "endDate">[]): PositionedMarker[];
+/** A range band placed on the timeline */
+export interface PositionedBand {
+    band: GanttRangeBand;
+    leftPx: number;
+    widthPx: number;
+}
+export interface DrawnRange {
+    startDate: Dayjs;
+    endDate: Dayjs;
+    /** Where the snapped range sits on the timeline - the ghost bar's box (px) */
+    leftPx: number;
+    widthPx: number;
+}
+/**
+ * Places range bands on the timeline, dropping the ones that miss the rendered range
+ * entirely (a band that only overlaps it is clipped to the part that is on screen)
+ */
+export declare function computeBandRects(bands: GanttRangeBand[], timelineTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey): PositionedBand[];
+/**
+ * Turns a range drawn on the timeline into dates snapped to the current scale
+ *
+ * Both arguments are px from the timeline's left edge - the same coordinates the bars
+ * are positioned in. The range snaps outwards to the ticks the two ends landed on, so the
+ * proposed task lines up with the columns on screen, and a range that stays inside one
+ * tick still comes out one tick long. Null when the timeline has no cells.
+ */
+export declare function snapDrawnRange(startPx: number, endPx: number, timelineTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey): DrawnRange | null;
+/**
+ * Builds the top header groups from the bottom cells
+ * Used by the header component
+ */
+export declare function createTopHeaderGroups(bottomCells: GanttBottomRowCell[], selectedScale: GanttScaleKey, localeOptions?: GanttLocaleOptions): GanttTopHeaderGroup[];
+/**
+ * Computes the timeline data
+ * Returns bottomCells and transformedTasks for the given rawTasks and scale
+ *
+ * `visibleRange` pins either end of the window. A pinned end is used verbatim
+ * (no task fitting, no buffer padding) so the chart renders exactly what was
+ * asked for; an open end still auto-fits to the tasks as before.
+ *
+ * With hierarchy on, a parentId tree is built and parents are recomputed as summary rows.
+ * (Rolled up before the range is computed so dates derived from children also widen an
+ *  auto-fitted timeline)
+ *
+ * `extension` widens the auto-fitted range beyond the usual buffer - that is how scrolling
+ * past an edge grows the timeline instead of hitting a wall. An end pinned by
+ * `visibleRange` is left exactly where the host put it.
+ */
+export declare function computeTimelineData(rawTasks: Task[], selectedScale: GanttScaleKey, visibleRange?: GanttVisibleRange, hierarchy?: boolean, extension?: GanttRangeExtension): TimelineData;

package/dist/utils/transformData.d.ts

@@ -0,0 +1,15 @@
+import { GanttBottomRowCell, GanttScaleKey } from '../types/gantt';
+import { Task, TaskTransformed } from '../types/task';
+import { TaskTree } from '../core/tree';
+/**
+ * Sort tasks by their sequence hierarchy
+ *
+ * Row order comes from this and nothing else - '1.10' lands after '1.2' because the
+ * segments compare as numbers.
+ */
+export declare function sortTasksBySequence(tasks: Task[]): Task[];
+/**
+ * @param tree the parentId tree (only when hierarchy is on) - given, depth comes from the
+ *             parent chain instead of sequence, and rows with children are marked as summaries
+ */
+export declare function transformTasks(tasks: Task[], timelineTicks: GanttBottomRowCell[], selectedScale: GanttScaleKey, tree?: TaskTree): TaskTransformed[];

package/dist/utils/viewport.d.ts

@@ -0,0 +1,95 @@
+import { GanttRangeExtension, GanttScaleKey } from '../types/gantt';
+/**
+ * The zoom ladder, finest first
+ *
+ * Declaration order in GANTT_SCALE_CONFIG is the ladder - the scale selector lists the
+ * scales in the same order, so a wheel step and an arrow key move the same way.
+ */
+export declare const SCALE_LADDER: GanttScaleKey[];
+/**
+ * Roughly how many px one millisecond takes at a scale
+ *
+ * Exact for every scale whose ticks are a fixed duration, and close enough for the
+ * month-tick scales (a month is 28-31 days), which is all `fitScale` needs.
+ */
+export declare function pxPerMs(scale: GanttScaleKey): number;
+/** Moves `direction` places along the ladder (negative = finer), clamped at both ends */
+export declare function stepScale(scale: GanttScaleKey, direction: number): GanttScaleKey;
+/**
+ * Finest scale at which `durationMs` still fits in `viewportPx`
+ *
+ * Falls back to the coarsest scale when even that is too narrow - a project that does not
+ * fit anywhere is shown as wide as the ladder goes rather than not zoomed at all.
+ */
+export declare function fitScale(durationMs: number, viewportPx: number): GanttScaleKey;
+export interface ZoomAccumulator {
+    /** Wheel delta collected during this gesture */
+    delta: number;
+    /** Timestamp of the last wheel event */
+    lastEventAt: number;
+    /** This gesture has already produced its step - the next pause unlocks it */
+    locked: boolean;
+}
+export declare const INITIAL_ZOOM_ACCUMULATOR: ZoomAccumulator;
+/**
+ * Folds one wheel delta into the accumulator and reports whether it makes a scale step
+ *
+ * `step` is -1 (finer), 0 (nothing yet) or 1 (coarser). Small trackpad deltas add up until
+ * they reach the threshold, and once a gesture has stepped, everything else it fires is
+ * swallowed until the stream pauses - so a pinch that runs for half a second is one scale
+ * step, not five, while two deliberate flicks are still two.
+ */
+export declare function accumulateZoom(state: ZoomAccumulator, deltaY: number, now: number): {
+    state: ZoomAccumulator;
+    step: number;
+};
+/** How close to the edge a drag has to get before the timeline starts scrolling (px) */
+export declare const EDGE_SCROLL_THRESHOLD = 48;
+/** Fastest the timeline scrolls itself, at the very edge (px per frame) */
+export declare const EDGE_SCROLL_MAX_SPEED = 22;
+/**
+ * Auto-scroll speed for a pointer at `clientX`, in px per frame
+ *
+ * 0 while the pointer is away from the edges, then ramps linearly to `maxSpeed` at the
+ * edge itself, so a drag creeps at the boundary and races once it is pinned against it.
+ * The zone never eats more than half the viewport, so a narrow timeline does not
+ * auto-scroll everywhere.
+ */
+export declare function edgeScrollVelocity(clientX: number, left: number, right: number, threshold?: number, maxSpeed?: number): number;
+export declare const NO_RANGE_EXTENSION: GanttRangeExtension;
+/**
+ * Cap on the ticks added per side
+ *
+ * Every task is positioned by walking the tick array, so an unbounded range would make
+ * that walk unbounded too. 2000 ticks is years of headroom at every scale.
+ */
+export declare const MAX_RANGE_EXTENSION_TICKS = 2000;
+interface ExtendRangeParams {
+    current: GanttRangeExtension;
+    scrollLeft: number;
+    /** Visible timeline width - the task list pane's share already taken off */
+    viewportPx: number;
+    /** Width of the whole rendered timeline */
+    totalPx: number;
+    /** Average px one tick takes at the current scale */
+    pxPerTick: number;
+    /**
+     * Ends that are still free to move (default: both)
+     *
+     * An end pinned by `visibleRange` cannot grow, and extending it would just be recomputed
+     * into the same timeline on every scroll event.
+     */
+    canExtend?: {
+        before: boolean;
+        after: boolean;
+    };
+}
+/**
+ * The extension the range should grow to, or null when the current one still covers the view
+ *
+ * Extends by roughly a viewport at a time once the view comes within half a viewport of
+ * either end, so the user never reaches the wall. One extension is always enough to push
+ * the edge back out of the trigger zone, so this cannot loop.
+ */
+export declare function extendRangeForScroll({ current, scrollLeft, viewportPx, totalPx, pxPerTick, canExtend, }: ExtendRangeParams): GanttRangeExtension | null;
+export {};