prime-ui-kit 0.10.0 → 0.11.1

package/dist/components/file-upload/FileUpload.d.ts

@@ -1,17 +1,88 @@
 import * as React from "react";
-import { type FieldFrameProps, type FieldRootDomProps } from "@/internal/FieldFrame";
-import type { ControlSize, PaletteColor, TextTone } from "@/internal/states";
-/** Drop zone treatment: `dashed` shows the drop affordance line, `solid` keeps only the fill. */
+import type { UploadQueue } from "../../hooks/useUploadQueue";
+import { type FieldFrameProps, type FieldRootDomProps } from "../../internal/FieldFrame";
+import type { ControlSize, PaletteColor, TextTone, Tone } from "../../internal/states";
+/** The look of the drop zone: `dashed` — the drop affordance line; `solid` — its fill only. */
 export type FileUploadVariant = "dashed" | "solid";
+/**
+ * How files are added: `dropzone` — the drop area; `button` — a compact picker button (a paperclip)
+ * with no zone and no drop; `tile` — an add tile at the end of the files, the whole set a drop target.
+ */
+export type FileUploadTrigger = "dropzone" | "button" | "tile";
+/**
+ * `list` — rows: badge or preview, name, size and status, a progress bar across the row. `grid` —
+ * square tiles that follow the set's width (5 · 4 · 3 · 2 across); `strip` — one row of tiles that
+ * scrolls sideways. Tiles show a picture, a video's first frame or the format badge.
+ */
+export type FileUploadLayout = "list" | "grid" | "strip";
+/** One file of the set (application data, drawn in array order): on the server or on its way. */
+export type FileUploadFile = {
+    /** Stable unique id: survives a reorder. An upload of the `queue` shares its item's id. */
+    id: string;
+    /** File name with its extension: the format badge and the accessible name come from it. */
+    name: string;
+    /** Size in bytes, shown under the name; omitted — no size. */
+    size?: number;
+    /** MIME type; without it the kind is read from the name's extension. */
+    type?: string;
+    /** A picture or a video (a URL, or a local object URL); without it the file shows its format. */
+    src?: string;
+    /** What the picture shows: spoken in place of the name, never drawn. */
+    alt?: string;
+};
 export type FileUploadLabels = {
     /** Title of the built-in drop zone body. */
     title: string;
     /** Description under the title (formats, size limit). An empty string hides it. */
     description: string;
-    /** Text of the decorative «browse» button of the built-in body. */
+    /** Text of the browse button: decorative in a zone, the control itself with `trigger="button"`. */
     browse: string;
     /** Muted marker after the field label when `optional`. */
     optional: string;
+    /** Text of the add tile (`trigger="tile"`). */
+    add: string;
+    /** Accessible name of the add tile's file input. */
+    addLabel: string;
+    /** The add tile of an empty set: it spans the row. */
+    empty: string;
+    /** Second line of the empty add tile without `max`. */
+    emptyHint: string;
+    /** Text of the add tile when `max` is reached. */
+    full: string;
+    /** Counter on the add tile: `{count}`, `{max}`. */
+    count: string;
+    /** Pill of the first tile with `cover`. */
+    cover: string;
+    /** A file waiting for a free slot. */
+    queued: string;
+    /** A file in flight: `{percent}`. */
+    uploading: string;
+    /** A failed file whose upload gave no reason. */
+    failed: string;
+    /** Name of the progress bar of a row: `{name}`. */
+    progress: string;
+    /** Name of the disk that cancels a tile's upload in flight: `{name}`. */
+    cancel: string;
+    /** Name of the retry button of a failed file: `{name}`. */
+    retry: string;
+    /** Name of the remove button of a file: `{name}`. */
+    remove: string;
+    /** Live region: a file was removed: `{name}`. */
+    removed: string;
+    /** Live region: a reorder put another file first, the new cover: `{name}`. */
+    coverChanged: string;
+    /** Live region: the `onValueChange` promise of a change rejected, the files are as they were. */
+    changeFailed: string;
+    /** Live region: a file finished uploading: `{name}`. */
+    uploaded: string;
+    /** Live region: a file failed to upload: `{name}`, `{reason}`. */
+    uploadFailed: string;
+    /** Name of an image tile: `{position}`, `{name}`, `{status}` (` · ` and the upload state). */
+    tileImage: string;
+    /** Name of a video tile: `{position}`, `{name}`, `{status}`. */
+    tileVideo: string;
+    /** Name of any other file's tile: `{position}`, `{name}`, `{status}`. */
+    tileFile: string;
 };
 type DivProps = React.HTMLAttributes<HTMLDivElement> & {
     ref?: React.Ref<HTMLDivElement>;
@@ -53,7 +124,7 @@ export type FileUploadItemProps = DivProps & {
     /** Typography, spacing and the format badge follow the control tier (default: the host tier, else `m`). */
     size?: ControlSize;
 };
-/** A file row: format badge · name over description · actions, then the progress bar. */
+/** A file row: format badge or preview · name over description · actions, then the progress bar. */
 declare function FileUploadItem({ className, invalid, size: sizeProp, ...rest }: FileUploadItemProps): import("react/jsx-runtime").JSX.Element;
 declare namespace FileUploadItem {
     var displayName: string;
@@ -69,6 +140,19 @@ declare function FileUploadFormatBadge({ format, color, className, ...rest }: Fi
 declare namespace FileUploadFormatBadge {
     var displayName: string;
 }
+export type FileUploadItemPreviewProps = Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "color"> & {
+    /** The picture: a URL, or the local preview of a file being uploaded. */
+    src: string;
+    ref?: React.Ref<HTMLDivElement>;
+};
+/**
+ * An image file's picture in place of the format badge: a square kit Thumbnail of the row tier
+ * (decorative: the name names the file); an icon shows while it loads or if it fails.
+ */
+declare function FileUploadItemPreview({ src, className, ...rest }: FileUploadItemPreviewProps): import("react/jsx-runtime").JSX.Element;
+declare namespace FileUploadItemPreview {
+    var displayName: string;
+}
 export type FileUploadItemNameProps = DivProps;
 declare function FileUploadItemName({ className, ...rest }: FileUploadItemNameProps): import("react/jsx-runtime").JSX.Element;
 declare namespace FileUploadItemName {
@@ -89,40 +173,92 @@ declare namespace FileUploadItemActions {
 export type FileUploadItemProgressProps = Omit<DivProps, "children"> & {
     value: number;
     max?: number;
+    /** Fill color: `success` for a finished file, `danger` where a failed one stopped. Default `accent`. */
+    tone?: Tone;
     /** Accessible name of the bar; name the file. Default «Загрузка файла». */
     "aria-label"?: string;
 };
 /** Upload progress across the whole row: the kit ProgressBar. */
-declare function FileUploadItemProgress({ value, max, className, "aria-label": ariaLabel, ...rest }: FileUploadItemProgressProps): import("react/jsx-runtime").JSX.Element;
+declare function FileUploadItemProgress({ value, max, tone, className, "aria-label": ariaLabel, ...rest }: FileUploadItemProgressProps): import("react/jsx-runtime").JSX.Element;
 declare namespace FileUploadItemProgress {
     var displayName: string;
 }
-export type FileUploadRootProps = FieldRootDomProps & Omit<FieldFrameProps, "focusRing"> & {
+/**
+ * What the set needs of an upload queue (`useUploadQueue`): its files, and a hand to retry and
+ * remove them. `add` lets the field put picked files into it; `move` keeps its order in step with
+ * the tiles.
+ */
+export type FileUploadQueueSource = Pick<UploadQueue, "items" | "retry" | "remove"> & Partial<Pick<UploadQueue, "add" | "move">>;
+/** The props of the set itself, shared by `FileUpload.Root` and `FileUpload.Queue`. */
+type FileSetProps = {
+    /** Files in their order (controlled): on the server, or uploads of `queue` by their ids. */
+    value?: readonly FileUploadFile[];
+    /** Initial files (uncontrolled). */
+    defaultValue?: readonly FileUploadFile[];
+    /**
+     * The set changed: reordered, a file removed, files added to `queue`. Return
+     * the save's promise: the files it touches wait busy; a move or new files stand in
+     * their new places meanwhile, a removed file stays until the answer. Resolve — the change stands
+     * (a controlled owner applies `value` before resolving); reject — the set goes back (new files
+     * leave the queue) and `labels.changeFailed` is announced.
+     */
+    onValueChange?: (value: readonly FileUploadFile[]) => void | Promise<void>;
+    /** The uploads: `useUploadQueue(…)`. Its files that are not in `value` follow it in its order. */
+    queue?: FileUploadQueueSource;
+    layout?: FileUploadLayout;
+    /**
+     * Tiles (`grid`, `strip`): the first file is the cover — «Обложка» in place of its format pill,
+     * two by two in a grid. A file reordered first becomes the cover, and that is announced.
+     */
+    cover?: boolean;
+    /** Display of a file size. Default: Russian digits with Б · КБ · МБ · ГБ. */
+    formatSize?: (bytes: number) => string;
+    /** Read-only set: no add tile, no reorder, no remove. */
+    disabled?: boolean;
+    labels?: Partial<FileUploadLabels>;
+};
+export type FileUploadQueueProps = Omit<React.HTMLAttributes<HTMLUListElement>, "children" | "defaultValue"> & FileSetProps & {
+    ref?: React.Ref<HTMLUListElement>;
+};
+/**
+ * The files of a set with no picker of its own (a tray whose paperclip lives elsewhere): rows or
+ * tiles of `value` and the uploads of `queue`, with retry, remove and reorder.
+ */
+declare function FileUploadQueue(props: FileUploadQueueProps): import("react/jsx-runtime").JSX.Element;
+declare namespace FileUploadQueue {
+    var displayName: string;
+}
+export type FileUploadRootProps = FieldRootDomProps & Omit<FieldFrameProps, "focusRing"> & FileSetProps & {
     /** Tier. Default: the tier of the surrounding control (a form, a panel), else `m`. */
     size?: ControlSize;
+    trigger?: FileUploadTrigger;
     variant?: FileUploadVariant;
     /** Access to the hidden file input (open the picker programmatically). */
     inputRef?: React.Ref<HTMLInputElement>;
     accept?: string;
     multiple?: boolean;
-    /** Blocks picking and drag-and-drop. */
-    disabled?: boolean;
+    /** Most files in the set: the add tile counts them; files past it are not taken. */
+    max?: number;
     /** Invalid state: danger line and `aria-invalid`. A non-empty `error` implies it. */
     invalid?: boolean;
     /** Name of the file input inside a form. */
     name?: string;
+    /** Files picked or dropped (of `accept`, cut to `max`). Not called with `queue.add`: they go there. */
     onFilesChange?: (files: File[]) => void;
-    labels?: Partial<FileUploadLabels>;
     /** Id of the file input; generated when omitted. */
     id?: string;
-    /** Custom body (`FileUpload.Body`); replaces the built-in icon, title, description and button. */
+    /**
+     * A zone: a custom body (`FileUpload.Body`) instead of the built-in one. `trigger="button"`:
+     * the button's content (`Button.Icon` and text; an icon alone makes it icon-only).
+     */
     children?: React.ReactNode;
 };
 /**
- * The field: label · drop zone · hint or error. `className`, `ref` and the rest go to the frame,
- * `id` and `aria-label` to the hidden file input.
+ * The field: label · the trigger (a drop zone, a picker button or an add tile) · the files of
+ * `value` and `queue` · hint or error. `className`, `ref` and the rest go to the frame, `id` and
+ * `aria-label` to the file input (the button with `trigger="button"`).
  */
-declare function FileUploadRoot({ size: sizeProp, variant, inputRef, accept, multiple, disabled, invalid, name, onFilesChange, label, required, optional, hint, error, id, labels: labelsProp, "aria-label": ariaLabel, children, ...rest }: FileUploadRootProps): import("react/jsx-runtime").JSX.Element;
+declare function FileUploadRoot(props: FileUploadRootProps): import("react/jsx-runtime").JSX.Element;
 declare namespace FileUploadRoot {
     var displayName: string;
 }
@@ -134,9 +270,11 @@ export declare const FileUpload: {
     Description: typeof FileUploadDescription;
     Item: typeof FileUploadItem;
     FormatBadge: typeof FileUploadFormatBadge;
+    ItemPreview: typeof FileUploadItemPreview;
     ItemName: typeof FileUploadItemName;
     ItemDescription: typeof FileUploadItemDescription;
     ItemActions: typeof FileUploadItemActions;
     ItemProgress: typeof FileUploadItemProgress;
+    Queue: typeof FileUploadQueue;
 };
 export {};

package/dist/components/gallery/Gallery.d.ts

@@ -0,0 +1,79 @@
+import * as React from "react";
+import { type TransferDirection, type TransferLabels, type TransferState } from "../../internal/transfer";
+import { type GalleryLayout } from "./layout";
+export type GalleryItem = {
+    /** Default `image`. */
+    type?: "image" | "video";
+    src: string;
+    /** A still of a video before it plays. */
+    poster?: string;
+    /** What the picture shows; names the tile that opens it. */
+    alt?: string;
+    /** The natural size: the tile keeps its aspect ratio before anything loads. Default 4 : 3. */
+    width?: number;
+    height?: number;
+    /** A video's length in seconds, shown before its metadata loads. */
+    duration?: number;
+    /** The tile's transfer, either way (`UploadItem.status` of `useUploadQueue`, or `remote`). */
+    transfer?: TransferState;
+    /** Share transferred, 0…1 (`UploadItem.progress`). */
+    transferProgress?: number;
+    /** Which way it goes: the words only. Default `upload`. */
+    transferDirection?: TransferDirection;
+};
+/** The tile strings, and the transfer strings every transferring part shares. */
+export type GalleryLabels = {
+    /** The name of a tile that opens the viewer; `{name}` is `alt`, else `photo` / `video`. */
+    open: string;
+    photo: string;
+    video: string;
+} & TransferLabels;
+export type GalleryProps = React.HTMLAttributes<HTMLDivElement> & {
+    /** One photo or video, or an album of 2–10 laid out by their aspect ratios. More are not shown. */
+    items: readonly GalleryItem[];
+    /**
+     * The album opens in the kit's `MediaViewer` (default `true`): a tile opens it at that item, the
+     * whole album its set, out of the tile and back into it. `false` — no viewer of the kit: open your
+     * own from `onOpenChange` and `onIndexChange`.
+     */
+    viewer?: boolean;
+    /** The viewer is open (controlled). */
+    open?: boolean;
+    /** Initially open (uncontrolled). Default `false`. */
+    defaultOpen?: boolean;
+    /** A tile opened the viewer (`true`), or the viewer closed (`false`). */
+    onOpenChange?: (open: boolean) => void;
+    /** The item the viewer shows (controlled); a tile sets it to its own. */
+    index?: number;
+    /** The item shown first (uncontrolled). Default `0`. */
+    defaultIndex?: number;
+    /** A tile was activated, or the viewer turned its page: the item now shown. */
+    onIndexChange?: (index: number) => void;
+    /**
+     * Cancel the transfer of a tile (the disk with the cross in its middle). A returned promise keeps
+     * the disk pending; a rejection leaves the transfer running and is announced.
+     */
+    onCancel?: (index: number) => void | Promise<void>;
+    /** Transfer a failed tile again; a promise works the same. */
+    onRetry?: (index: number) => void | Promise<void>;
+    /** Fetch a `remote` tile (the download arrow); a promise works the same. */
+    onDownload?: (index: number) => void | Promise<void>;
+    labels?: Partial<GalleryLabels>;
+    /** Laid over the gallery, above every tile (a caption pill, a message's time). */
+    children?: React.ReactNode;
+    ref?: React.Ref<HTMLDivElement>;
+};
+/** The layout of `items`: their ratios read once, nothing measured. */
+export declare function galleryLayoutOf(items: readonly GalleryItem[]): GalleryLayout;
+/**
+ * Photos and videos as a messenger album: one, or 2–10 laid out by their aspect ratios (side by
+ * side, stacked, a tall one beside a column, rows for larger albums), every tile in its final box
+ * before anything loads — nothing is measured. A video tile shows its first frame, a play mark and
+ * its length; a tile opens the album in `MediaViewer` at that item (or your own viewer:
+ * `viewer={false}` with the open and index triads); a tile on its way, either way, dims under the
+ * shared transfer disk.
+ */
+export declare function Gallery({ items: itemsProp, viewer, open: openProp, defaultOpen, onOpenChange, index: indexProp, defaultIndex, onIndexChange, onCancel, onRetry, onDownload, labels: labelsProp, className, style, children, ref, ...rest }: GalleryProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Gallery {
+    var displayName: string;
+}

package/dist/components/gallery/layout.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The album layout of a gallery, from the aspect ratios of its items alone — nothing is measured,
+ * so every tile has its final box before a byte loads.
+ *
+ * The geometry is the messenger album's: the orientation of each item (`w` wide, `n` narrow, `q`
+ * about square) and the average ratio pick the shape for 2–4 items (side by side, stacked, a tall
+ * one beside a column, a wide one over a row); 5–10 items are laid out in rows, the partition
+ * chosen by how close the album comes to a square and how even its rows are, fewer items above
+ * more and rows of like heights. Everything is computed on a box of width 1; gaps are not part of the math (the tiles are
+ * inset by half a gap at every inner edge in CSS).
+ */
+/** A tile in fractions of the gallery's box: `x` and `w` of its width, `y` and `h` of its height. */
+export type GalleryTile = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export type GalleryLayout = {
+    /** Width ÷ height of the whole gallery. */
+    ratio: number;
+    /**
+     * The share of the size cap the gallery is wide: below 1 for a lone portrait (its height reaches
+     * the cap instead), else 1.
+     */
+    widthFactor: number;
+    tiles: GalleryTile[];
+};
+/** At most this many items are laid out. */
+export declare const GALLERY_MAX = 10;
+/** Width ÷ height of an item, kept between a tall portrait and a wide panorama. */
+export declare function itemRatio(width: number | undefined, height: number | undefined, single: boolean): number;
+/** The layout of `ratios` (width ÷ height of each item, in order). */
+export declare function layoutGallery(ratios: readonly number[]): GalleryLayout;

package/dist/components/gantt/Gantt.d.ts

@@ -0,0 +1,102 @@
+import { type Locale } from "date-fns";
+import * as React from "react";
+import type { ControlSize } from "../../internal/states";
+import { type GanttBar, type GanttDates, type GanttScale } from "./ganttModel";
+export type { GanttBar, GanttDates, GanttScale } from "./ganttModel";
+/** System strings; `{label}`, `{start}`, `{end}`, `{date}`, `{progress}` are replaced. */
+export type GanttLabels = {
+    /** Heading of the first column. */
+    rowsHeader: string;
+    /** Accessible name of the time axis column. */
+    timeline: string;
+    /** Accessible name of the zoom switch. */
+    scale: string;
+    /** Zoom segments. */
+    day: string;
+    week: string;
+    month: string;
+    /** The button that scrolls to today, and the label on the today line. */
+    today: string;
+    /** Accessible name of a bar; `{start}` and `{end}` are its first and last day. */
+    bar: string;
+    /** Accessible name of a milestone. */
+    milestone: string;
+    /** Appended to a bar's name when it has `progress`. */
+    progress: string;
+    /** Description of an editable bar: the editing keys. */
+    editHint: string;
+    /** Duration of a bar in the tooltip; `{days}` is its number of days. */
+    duration: string;
+    /** Announced when `onBarChange` rejects and the bar returns to its dates. */
+    changeFailed: string;
+    /** Label of a bar being created (the ghost) and of its announcement. */
+    newBar: string;
+    /** Description of a row header when bars can be created: the creating key. */
+    createHint: string;
+    /** Announced when `onBarCreate` rejects and the new bar fades out. */
+    createFailed: string;
+    /** Screen-reader announcement while skeleton rows are shown. */
+    loading: string;
+    /** Default empty-state text (when `empty` is not set). */
+    empty: string;
+};
+export type GanttProps<Row, Bar extends GanttBar = GanttBar> = Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "onSelect"> & {
+    /** The outer surface `<div>`; `aria-label` / `aria-labelledby` name the grid inside. */
+    ref?: React.Ref<HTMLDivElement>;
+    /** Rows: people, rooms, vehicles, tasks. Only the rows in view are rendered. */
+    rows: Row[];
+    /** Stable row id. */
+    getRowKey: (row: Row) => React.Key;
+    /** Row name: the first column text by default, and the row header for assistive tech. */
+    getRowLabel: (row: Row) => string;
+    /** Bars of a row; overlapping bars stack into lanes. */
+    getRowBars: (row: Row) => Bar[];
+    /** First-column content instead of the label (a name with a role or a code). */
+    renderRow?: (row: Row) => React.ReactNode;
+    /** A picture before the row content (an `Avatar`); on a narrow chart the column keeps only it. */
+    renderRowAvatar?: (row: Row) => React.ReactNode;
+    /** Zoom, controlled. */
+    scale?: GanttScale;
+    /** Initial zoom, uncontrolled. */
+    defaultScale?: GanttScale;
+    onScaleChange?: (scale: GanttScale) => void;
+    /** The time axis; default — every bar and today with room on both sides. */
+    range?: GanttDates;
+    /** The day of the today line. Default — the current day. */
+    today?: Date;
+    /** date-fns locale of the header and the dates. Default `ru`. */
+    locale?: Locale;
+    size?: ControlSize;
+    /** No moving, resizing or creating; bars still select and show their dates. */
+    readOnly?: boolean;
+    /** Skeleton rows while there are no rows yet; with rows they stay and the grid is busy. */
+    loading?: boolean;
+    /** Empty-state content (e.g. `EmptyPage`); defaults to `labels.empty`. */
+    empty?: React.ReactNode;
+    /** Content at the start of the toolbar (title, filters); the zoom and «Сегодня» sit at its end. */
+    toolbar?: React.ReactNode;
+    /** Max height of the scroll viewport in px; `"fill"` — the chart takes its parent's height. */
+    scrollHeight?: number | "fill";
+    /** A bar was activated (click, Enter, Space): open its record. */
+    onSelect?: (bar: Bar, row: Row) => void;
+    /**
+     * New dates of a bar after a drag or an editing key, in whole scale units. Update your data with
+     * them. A returned Promise keeps the bar at the new dates and busy until it settles; on reject it
+     * glides back. Without it, bars cannot be edited.
+     */
+    onBarChange?: (dates: GanttDates, bar: Bar, row: Row) => void | Promise<void>;
+    /**
+     * A bar was drawn on an empty spot of a row (drag, double-click, long-press, `N`), in whole scale
+     * units. Add it to your data. A returned Promise keeps a busy ghost in place until it settles;
+     * on reject the ghost fades out. Without it, nothing can be created.
+     */
+    onBarCreate?: (dates: GanttDates, row: Row) => void | Promise<void>;
+    labels?: Partial<GanttLabels>;
+};
+/**
+ * A resource or project schedule: rows with bars on a time axis (day / week / month), a sticky
+ * first column and header, weekends and a today line. Bars select, move and resize by pointer and
+ * keyboard through an async `onBarChange`, and are drawn on empty space through `onBarCreate`.
+ * Rows and the time axis are virtualized: thousands of rows over years stay fast.
+ */
+export declare function Gantt<Row, Bar extends GanttBar = GanttBar>({ rows, getRowKey, getRowLabel, getRowBars, renderRow, renderRowAvatar, scale: scaleProp, defaultScale, onScaleChange, range: rangeProp, today: todayProp, locale, size, readOnly, loading, empty, toolbar, scrollHeight, onSelect, onBarChange, onBarCreate, labels: labelsProp, className, style, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, ref, ...rest }: GanttProps<Row, Bar>): import("react/jsx-runtime").JSX.Element;

package/dist/components/gantt/GanttBar.d.ts

@@ -0,0 +1,51 @@
+import type { Locale } from "date-fns";
+import { type GanttBar, type GanttDates, type GanttScale } from "./ganttModel";
+export type GanttBarViewProps = {
+    bar: GanttBar;
+    /** Dates on screen: the data, or the pending change while `onBarChange` runs. */
+    dates: GanttDates;
+    /** Days from the range start to `dates.start`. */
+    x: number;
+    lane: number;
+    scale: GanttScale;
+    locale: Locale;
+    /** Accessible name for the given dates (label, spoken dates, progress). */
+    nameFor: (dates: GanttDates) => string;
+    /** «14 дн.» — the duration in the tooltip. */
+    formatDuration: (days: number) => string;
+    editable: boolean;
+    pending: boolean;
+    /** The roving tab stop of the chart. */
+    active: boolean;
+    /** Id of the hidden «how to edit» hint. */
+    hintId?: string;
+    /** Length of one day in px, measured on the axis. */
+    dayPx: () => number;
+    /** −1 in a right-to-left chart: pointer travel runs against the time axis. */
+    direction: () => 1 | -1;
+    /** The chart's horizontal scroll position: a gesture counts the auto-scroll it caused. */
+    scrollLeft: () => number;
+    /** Keeps the chart scrolling while a drag holds an edge; `stop` ends it. */
+    autoScroll: {
+        follow: (clientX: number, onScrolled: () => void) => void;
+        stop: () => void;
+    };
+    onActivate: () => void;
+    onFocusBar: () => void;
+    /** The tooltip opened (with its closer) or closed: the chart closes open tooltips on scroll. */
+    onTipChange: (id: string, close: (() => void) | null) => void;
+    /** No tooltip for a bar hidden under the sticky column or the edges: nothing to point at. */
+    canShowTip: (id: string) => boolean;
+    onCommit: (dates: GanttDates) => void;
+    /** A drag started or ended: the chart keeps a dragged bar rendered wherever it is scrolled. */
+    onDragChange: (id: string, dragging: boolean) => void;
+    barRef: (node: HTMLButtonElement | null) => void;
+};
+/**
+ * One bar: a `<button>` placed in days, with a Tooltip (dates and duration) on hover and focus. A
+ * pointer drags the body (move) or a grip (start / end): the bar follows the pointer exactly, the
+ * dates snap to whole days (to the zoom's unit with Alt) with hysteresis, a guide marks the snapped
+ * edge at the week and month zoom, and the tooltip shows the new dates. Release commits through
+ * `onCommit`; Escape or a cancelled pointer drops it. On touch a long press picks the bar up.
+ */
+export declare function GanttBarView({ bar, dates, x, lane, scale, locale, nameFor, formatDuration, editable, pending, active, hintId, dayPx, direction, scrollLeft, autoScroll, onActivate, onFocusBar, onTipChange, canShowTip, onCommit, onDragChange, barRef, }: GanttBarViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/gantt/GanttRow.d.ts

@@ -0,0 +1,75 @@
+import type { Locale } from "date-fns";
+import * as React from "react";
+import { type GanttBar, type GanttDates, type GanttScale } from "./ganttModel";
+/** A bar being created: drawn by the pointer, waiting for `onBarCreate`, or fading after a refusal. */
+export type GanttGhost = {
+    id: string;
+    dates: GanttDates;
+    status: "drawing" | "pending" | "leaving";
+};
+export type GanttTrackEvent = "pointerDown" | "pointerMove" | "pointerUp" | "pointerCancel" | "pointerLeave" | "contextMenu" | "doubleClick";
+/**
+ * Stable callbacks from the chart to its rows. They read the chart's latest state themselves, so a
+ * row re-renders only when its own props change — scrolling mounts new rows and leaves the rest.
+ */
+export type GanttRowContext = {
+    register: (id: string) => (node: HTMLElement | null) => void;
+    focus: (id: string) => void;
+    select: (barId: string, rowIndex: number) => void;
+    commit: (barId: string, rowIndex: number, dates: GanttDates) => void;
+    nameFor: (bar: GanttBar, dates: GanttDates) => string;
+    formatDuration: (days: number) => string;
+    track: (event: GanttTrackEvent, rowIndex: number, native: React.SyntheticEvent) => void;
+    registerTip: (id: string, close: (() => void) | null) => void;
+    /** Whether enough of the cell is visible on the timeline for a tooltip to point at it. */
+    canShowTip: (id: string) => boolean;
+    onDragChange: (id: string, dragging: boolean) => void;
+    dayPx: () => number;
+    direction: () => 1 | -1;
+    scrollLeft: () => number;
+    autoScroll: {
+        follow: (clientX: number, onScrolled: () => void) => void;
+        stop: () => void;
+    };
+};
+export type GanttRowProps = {
+    ctx: GanttRowContext;
+    index: number;
+    rowKey: React.Key;
+    navId: string;
+    label: string;
+    bars: readonly GanttBar[];
+    lanes: ReadonlyMap<string, number>;
+    laneCount: number;
+    top: number;
+    measureRef: (node: HTMLElement | null) => void;
+    /** The row's data and the first-column renderers (stable while the chart's props are). */
+    row: unknown;
+    renderRow?: (row: unknown) => React.ReactNode;
+    renderRowAvatar?: (row: unknown) => React.ReactNode;
+    ghost: GanttGhost | undefined;
+    ghostLane: number;
+    hover: {
+        x: number;
+        span: number;
+    } | null;
+    /** The chart's tab stop when it is in this row, else `null`. */
+    tabStop: string | null;
+    pending: ReadonlyMap<string, GanttDates>;
+    dragging: ReadonlySet<string>;
+    /** Visible time window in days (`from` > `to` — no window yet: render every bar). */
+    windowFrom: number;
+    windowTo: number;
+    scale: GanttScale;
+    rangeStart: number;
+    locale: Locale;
+    newBarLabel: string;
+    editableAtAll: boolean;
+    creatable: boolean;
+    hintId: string;
+    createHintId: string;
+};
+declare function GanttRowView({ ctx, index, navId, label, bars, lanes, laneCount, top, measureRef, row, renderRow, renderRowAvatar, ghost, ghostLane, hover, tabStop, pending, dragging, windowFrom, windowTo, scale, rangeStart, locale, newBarLabel, editableAtAll, creatable, hintId, createHintId, }: GanttRowProps): import("react/jsx-runtime").JSX.Element;
+/** One row of the chart: memoized, so scrolling renders only the rows that come into view. */
+export declare const GanttRow: React.MemoExoticComponent<typeof GanttRowView>;
+export {};