prime-ui-kit 0.9.1 → 0.9.2

package/dist/color-picker.js

@@ -1,8 +1,8 @@
 import {
   ColorPicker,
   parseColor
-} from "./chunks/chunk-KCQFOORX.js";
-import "./chunks/chunk-NHOWNIAR.js";
+} from "./chunks/chunk-IQELQNMR.js";
+import "./chunks/chunk-ZEFCDEEQ.js";
 export {
   ColorPicker,
   parseColor

package/dist/components/data-table/DataTable.d.ts

@@ -29,6 +29,11 @@ export type DataTableProps<Row> = Omit<React.HTMLAttributes<HTMLDivElement>, "ch
     /** The outer card-fill `<div>`. */
     ref?: React.Ref<HTMLDivElement>;
     columns: DataTableColumn<Row>[];
+    /**
+     * Ids of columns not rendered (head, body, skeleton, state rows). A column with
+     * `hideable: false` stays. The consumer owns the list and the control that changes it.
+     */
+    hiddenColumns?: string[];
     rows: Row[];
     size?: ControlSize;
     className?: string;
@@ -101,4 +106,4 @@ export type DataTableProps<Row> = Omit<React.HTMLAttributes<HTMLDivElement>, "ch
     /** Panel above the table (search, filters, actions). Wraps on narrow widths. */
     toolbar?: React.ReactNode;
 };
-export declare function DataTable<Row>({ columns, rows, size, className, showHeader, stickyHeader, stickyFirstColumn, getRowKey, onRowClick, loading, empty, labels: labelsProp, rowDividers, columnDividers, sort, defaultSort, onSortChange, paging, page, defaultPage, onPageChange, pageSize, infiniteBatchSize, hasMore, loadingMore, onLoadMore, scrollHeight, fullWidth, highlightRowOnHover, highlightColumnOnHover, striped, getRowLabel, selectable, selected, defaultSelected, onSelectedChange, getRowChildren, renderExpanded, isRowExpandable, expanded, defaultExpanded, onExpandedChange, error, loadingRows, toolbar, ref, ...rest }: DataTableProps<Row>): import("react/jsx-runtime").JSX.Element;
+export declare function DataTable<Row>({ columns: allColumns, hiddenColumns, rows, size, className, showHeader, stickyHeader, stickyFirstColumn, getRowKey, onRowClick, loading, empty, labels: labelsProp, rowDividers, columnDividers, sort, defaultSort, onSortChange, paging, page, defaultPage, onPageChange, pageSize, infiniteBatchSize, hasMore, loadingMore, onLoadMore, scrollHeight, fullWidth, highlightRowOnHover, highlightColumnOnHover, striped, getRowLabel, selectable, selected, defaultSelected, onSelectedChange, getRowChildren, renderExpanded, isRowExpandable, expanded, defaultExpanded, onExpandedChange, error, loadingRows, toolbar, ref, ...rest }: DataTableProps<Row>): import("react/jsx-runtime").JSX.Element;

package/dist/components/data-table/types.d.ts

@@ -32,4 +32,9 @@ export type DataTableColumn<Row> = {
      * such a column the table fills its container instead of growing to its content width.
      */
     grow?: boolean;
+    /**
+     * The column can be hidden through the table's `hiddenColumns`. Default `true`; `false` for the
+     * key column that names the row — it stays even when its id is listed.
+     */
+    hideable?: boolean;
 };

package/dist/components/dnd/Dnd.d.ts

@@ -1,6 +1,6 @@
 import * as React from "react";
 import { type DragItem, type DragOutcome } from "./dragSession";
-import type { Point, Rect } from "./geometry";
+import { type Point, type Rect } from "./geometry";
 import { type DndLabels } from "./labels";
 import { type ReorderReturn } from "./useSortableList";
 export type { DragItem, DragOutcome } from "./dragSession";

package/dist/components/dnd/dragSession.d.ts

@@ -20,6 +20,11 @@ export type DragSnapshot = {
     pointerKind: PointerKind | null;
     /** The drop target the pointer is over right now, by registered id. */
     overId: string | null;
+    /**
+     * The `holdsDrop` target the drop stays aimed at while the pointer crosses empty space: the last
+     * one it was over that would take the item. Null once the pointer is over any other target.
+     */
+    heldId: string | null;
     canDrop: boolean;
     /** The rect the lifted element occupied when the drag began: the size of the gap a list opens for it. */
     origin: Rect | null;
@@ -38,11 +43,15 @@ export type DropTargetEntry = {
     id: string;
     element: HTMLElement;
     accepts: (item: DragItem) => boolean;
+    /** Keeps the drop while the pointer crosses empty space (the gutter between two lists). */
+    holdsDrop: boolean;
     enter: (item: DragItem) => void;
     /** Called on every resolved pointer position; returns whether a drop here would be accepted. */
     over: (point: Point, item: DragItem) => boolean;
     leave: () => void;
     drop: (point: Point, item: DragItem) => void;
+    /** Drops where the pointer was last over this target: the release came over empty space. */
+    dropHeld: (item: DragItem) => void;
 };
 export type DragPreview = {
     /** The element the gesture started on, cloned by the overlay. */

package/dist/components/dnd/useDropTarget.d.ts

@@ -10,6 +10,11 @@ export type DropTargetOptions<TValue, TData = unknown> = {
     canDrop?: ((value: TValue, item: DragItem<TData>) => boolean) | undefined;
     onDrop: (value: TValue, item: DragItem<TData>) => void;
     disabled?: boolean | undefined;
+    /**
+     * The drop stays aimed here while the pointer crosses empty space after leaving (the gutter
+     * between lists), and a release there drops here at the last resolved spot.
+     */
+    holdsDrop?: boolean | undefined;
     onEnter?: ((item: DragItem<TData>) => void) | undefined;
     onLeave?: (() => void) | undefined;
     /** Flashes the target once a drop lands, so the eye can follow where the item went. */

package/dist/components/dnd/useFlipList.d.ts

@@ -1,11 +1,11 @@
 /**
  * WAAPI timing from the motion tokens (`--prime-motion-duration-<token>`,
- * `--prime-motion-easing-standard`), read at animation time so theme and app overrides apply;
+ * `--prime-motion-easing-<curve>`), read at animation time so theme and app overrides apply;
  * WAAPI cannot take `var()`.
  */
-export declare function motionTiming(duration: "fast" | "base"): KeyframeAnimationOptions;
+export declare function motionTiming(duration: "fast" | "base", curve?: "standard" | "enter" | "exit"): KeyframeAnimationOptions;
 /**
- * Animates layout changes of list items from the position currently on screen. Hit testing still uses
+ * Animates layout changes of list items (`data-dnd-item`) and of the gap (`data-dnd-gap`) from the position currently on screen. Hit testing still uses
  * `layoutRect`, so visual easing never changes a drop decision.
  */
 export declare function useFlipList(container: HTMLElement | null, layoutKey: string, selector: string, enabled: boolean): void;

package/dist/components/drawer/Drawer.d.ts

@@ -1,8 +1,8 @@
-import type * as React from "react";
+import * as React from "react";
 import { DialogBody, DialogClose, DialogDescription, DialogFooter, DialogHeader, DialogIcon, DialogTitle, DialogTrigger } from "@/components/modal/DialogParts";
 import type { ControlSize } from "@/internal/states";
 export type { DialogBodyProps as DrawerBodyProps, DialogCloseProps as DrawerCloseProps, DialogDescriptionProps as DrawerDescriptionProps, DialogFooterProps as DrawerFooterProps, DialogHeaderProps as DrawerHeaderProps, DialogIconProps as DrawerIconProps, DialogTitleProps as DrawerTitleProps, DialogTriggerProps as DrawerTriggerProps, } from "@/components/modal/DialogParts";
-export type DrawerSide = "left" | "right";
+export type DrawerSide = "left" | "right" | "bottom";
 export type DrawerLabels = {
     /** `aria-label` of the header close button. */
     close: string;
@@ -13,7 +13,7 @@ export type DrawerRootProps = {
     onOpenChange?: (open: boolean) => void;
     /** Escape closes the drawer. Default `true`. */
     closeOnEscape?: boolean;
-    /** A click on the scrim closes the drawer. Default `true`. */
+    /** A click on the scrim or a swipe toward the edge closes the drawer. Default `true`. */
     closeOnOutsideClick?: boolean;
     labels?: Partial<DrawerLabels>;
     children?: React.ReactNode;
@@ -23,9 +23,12 @@ declare namespace DrawerRoot {
     var displayName: string;
 }
 export type DrawerContentProps = React.HTMLAttributes<HTMLDivElement> & {
-    /** Edge the panel slides from. Default `right`. */
+    /** Edge the panel slides from; `bottom` is a sheet with a grab handle. Default `right`. */
     side?: DrawerSide;
-    /** Panel width: `s` 360 · `m` 480 · `l` 640 · `xl` 800. Full width below 640px of viewport. */
+    /**
+     * Panel width: `s` 360 · `m` 480 · `l` 640 · `xl` 800 (a bottom sheet is centred). Full width
+     * below 640px of viewport.
+     */
     size?: Exclude<ControlSize, "xs">;
     /** Class on the full-screen scrim. */
     overlayClassName?: string;

package/dist/components/dropdown/Dropdown.d.ts

@@ -51,6 +51,22 @@ declare function DropdownItem({ onSelect, disabled, tone, className, onClick, ..
 declare namespace DropdownItem {
     var displayName: string;
 }
+export type DropdownCheckboxItemProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "type" | "role" | "onSelect" | "onChange" | "defaultChecked"> & {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    ref?: React.Ref<HTMLButtonElement>;
+};
+/**
+ * A toggle inside the menu (show a column, turn a filter on, pick a view): the label where an item
+ * has it and a check mark at the end while checked, `role="menuitemcheckbox"`. Toggling keeps the
+ * menu open, so several can be set in a row.
+ */
+declare function DropdownCheckboxItem({ checked: checkedProp, defaultChecked, onCheckedChange, disabled, className, onClick, children, ...rest }: DropdownCheckboxItemProps): import("react/jsx-runtime").JSX.Element;
+declare namespace DropdownCheckboxItem {
+    var displayName: string;
+}
 type DivProps = React.HTMLAttributes<HTMLDivElement> & {
     ref?: React.Ref<HTMLDivElement>;
 };
@@ -113,6 +129,7 @@ export declare const Dropdown: {
     Description: typeof DropdownDescription;
     Group: typeof DropdownGroup;
     Item: typeof DropdownItem;
+    CheckboxItem: typeof DropdownCheckboxItem;
     ItemIcon: typeof DropdownItemIcon;
     ItemShortcut: typeof DropdownItemShortcut;
     Separator: typeof DropdownSeparator;

package/dist/components/index.d.ts

@@ -41,7 +41,7 @@ export type { DndDraggableProps, DndDropZoneProps, DndHandleProps, DndLabels, Dn
 export { Dnd } from "./dnd/Dnd";
 export { moveBefore } from "./dnd/useSortableList";
 export * from "./drawer/Drawer";
-export type { DropdownContentProps, DropdownDescriptionProps, DropdownGroupProps, DropdownHeaderProps, DropdownItemIconProps, DropdownItemProps, DropdownItemShortcutProps, DropdownRootProps, DropdownSeparatorProps, DropdownTitleProps, DropdownTriggerProps, } from "./dropdown/Dropdown";
+export type { DropdownCheckboxItemProps, DropdownContentProps, DropdownDescriptionProps, DropdownGroupProps, DropdownHeaderProps, DropdownItemIconProps, DropdownItemProps, DropdownItemShortcutProps, DropdownRootProps, DropdownSeparatorProps, DropdownTitleProps, DropdownTriggerProps, } from "./dropdown/Dropdown";
 export { Dropdown } from "./dropdown/Dropdown";
 export type { EmptyPageActionsProps, EmptyPageDescriptionProps, EmptyPageIconProps, EmptyPageRootProps, EmptyPageTitleProps, } from "./empty-page/EmptyPage";
 export { EmptyPage } from "./empty-page/EmptyPage";
@@ -53,6 +53,8 @@ export type { HintIconProps, HintRootProps } from "./hint/Hint";
 export { Hint } from "./hint/Hint";
 export type { InputAffixProps, InputClearButtonProps, InputCounterProps, InputFieldProps, InputIconProps, InputInlineAffixProps, InputLabels, InputRootProps, InputWrapperProps, } from "./input/Input";
 export { Input } from "./input/Input";
+export type { KanbanColumn, KanbanItemBadgesProps, KanbanItemCountProps, KanbanItemDescriptionProps, KanbanItemFooterProps, KanbanItemProps, KanbanItemTitleProps, KanbanLabels, KanbanMove, KanbanRootProps, KanbanValue, } from "./kanban/Kanban";
+export { Kanban } from "./kanban/Kanban";
 export type { KbdProps } from "./kbd/Kbd";
 export { Kbd } from "./kbd/Kbd";
 export type { LabelDescriptionProps, LabelIconProps, LabelLabels, LabelRootProps, } from "./label/Label";
@@ -71,6 +73,8 @@ export type { NotificationProviderProps } from "./notification/NotificationStore
 export { NotificationProvider, useNotifications, } from "./notification/NotificationStore";
 export type { PageContentActionsProps, PageContentBodyProps, PageContentDescriptionMeasure, PageContentDescriptionProps, PageContentHeaderProps, PageContentMaxWidth, PageContentRootProps, PageContentSectionProps, PageContentTitleProps, } from "./page-content/PageContent";
 export { PageContent } from "./page-content/PageContent";
+export type { PageToolbarActionsProps, PageToolbarChipsProps, PageToolbarRootProps, PageToolbarSectionsProps, PageToolbarToolsProps, PageToolbarViewProps, } from "./page-toolbar/PageToolbar";
+export { PageToolbar } from "./page-toolbar/PageToolbar";
 export type { PaginationLabels, PaginationProps } from "./pagination/Pagination";
 export { Pagination } from "./pagination/Pagination";
 export type { PopoverActionsProps, PopoverAnchorProps, PopoverCloseProps, PopoverContentProps, PopoverDescriptionProps, PopoverHeaderProps, PopoverRootProps, PopoverTitleProps, PopoverTriggerProps, } from "./popover/Popover";

package/dist/components/kanban/Kanban.d.ts

@@ -0,0 +1,129 @@
+import * as React from "react";
+/** A column of the board: application data, drawn in array order. */
+export type KanbanColumn = {
+    /** Stable unique id; the key of the column in `value`. */
+    id: string;
+    /** Heading of the column. */
+    title: string;
+    /** Most cards the column holds (a WIP limit): when full it refuses cards from other columns. */
+    limit?: number;
+};
+/** Where every card stands: column id → card ids in their order. */
+export type KanbanValue = Readonly<Record<string, readonly string[]>>;
+/** One applied move: card `id` went from column `from` to column `to` (may be the same) at `index`. */
+export type KanbanMove = {
+    id: string;
+    from: string;
+    to: string;
+    index: number;
+};
+/** System strings of the board. `{token}` values are substituted. */
+export type KanbanLabels = {
+    /** Spoken name of the count badge: `{count}`. */
+    count: string;
+    /** Spoken name of the count badge of a column with a `limit`: `{count}`, `{limit}`. */
+    countLimit: string;
+    /** Text of an empty column. */
+    empty: string;
+    /** Live region: a card moved to another column from the keyboard. */
+    moved: string;
+    /** Live region: the next column refused the card (full or `canDrop`). */
+    refused: string;
+};
+export declare const defaultKanbanLabels: KanbanLabels;
+export type KanbanRootProps<T> = Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "defaultValue"> & {
+    /** Columns in their order. */
+    columns: readonly KanbanColumn[];
+    /** Every card the board can show; `value` decides where each one stands. */
+    items: readonly T[];
+    /** Stable unique id of a card. */
+    getId: (item: T) => string;
+    /** Spoken by the live region. Defaults to the id. */
+    getLabel?: (item: T) => string;
+    /** Card ids per column (controlled). */
+    value?: KanbanValue;
+    /** Initial card ids per column (uncontrolled). */
+    defaultValue?: KanbanValue;
+    /** A card moved: the new placement first, then what moved. */
+    onValueChange?: (value: KanbanValue, move: KanbanMove) => void;
+    /** Renders one card; return a `Kanban.Item`. */
+    renderItem: (item: T) => React.ReactNode;
+    /** Renders the trailing actions of a column header (add a card, a menu). */
+    renderColumnActions?: (column: KanbanColumn) => React.ReactNode;
+    /** Refuses a card in a column (a workflow rule); the column turns `danger` before the release. */
+    canDrop?: (id: string, columnId: string) => boolean;
+    /** Columns show skeleton cards; the cards cross-fade in when it turns off. */
+    loading?: boolean;
+    /** No drag, no keyboard moves. */
+    disabled?: boolean;
+    labels?: Partial<KanbanLabels>;
+    ref?: React.Ref<HTMLDivElement>;
+};
+/**
+ * A board of columns: cards move within and between columns by pointer, touch (a hold) and
+ * keyboard (Alt + arrows). Mounts its own `Dnd.Root` unless one is already above it.
+ */
+declare function KanbanRoot<T>(props: KanbanRootProps<T>): import("react/jsx-runtime").JSX.Element;
+declare namespace KanbanRoot {
+    var displayName: string;
+}
+export type KanbanItemProps = Omit<React.HTMLAttributes<HTMLElement>, "id"> & {
+    /** This card cannot be dragged or moved. */
+    disabled?: boolean;
+    ref?: React.Ref<HTMLElement>;
+};
+/** One card: an `<li>` on a filled surface; drags by the whole card, moves with Alt + arrows. */
+declare function KanbanItem({ disabled, className, onKeyDown, children, ...rest }: KanbanItemProps): import("react/jsx-runtime").JSX.Element;
+declare namespace KanbanItem {
+    var displayName: string;
+}
+export type KanbanItemTitleProps = React.HTMLAttributes<HTMLSpanElement> & {
+    ref?: React.Ref<HTMLSpanElement>;
+};
+/** The card title: medium body text, wraps up to three lines. */
+declare function KanbanItemTitle({ className, ...rest }: KanbanItemTitleProps): import("react/jsx-runtime").JSX.Element;
+declare namespace KanbanItemTitle {
+    var displayName: string;
+}
+export type KanbanItemDescriptionProps = React.HTMLAttributes<HTMLSpanElement> & {
+    ref?: React.Ref<HTMLSpanElement>;
+};
+/** The muted meta line: id, due date. */
+declare function KanbanItemDescription({ className, ...rest }: KanbanItemDescriptionProps): import("react/jsx-runtime").JSX.Element;
+declare namespace KanbanItemDescription {
+    var displayName: string;
+}
+export type KanbanItemBadgesProps = React.HTMLAttributes<HTMLDivElement> & {
+    ref?: React.Ref<HTMLDivElement>;
+};
+/** A wrapping row of `Badge`s: labels, priority. */
+declare function KanbanItemBadges({ className, ...rest }: KanbanItemBadgesProps): import("react/jsx-runtime").JSX.Element;
+declare namespace KanbanItemBadges {
+    var displayName: string;
+}
+export type KanbanItemFooterProps = React.HTMLAttributes<HTMLDivElement> & {
+    ref?: React.Ref<HTMLDivElement>;
+};
+/** The bottom row: `Kanban.ItemCount`s at the start, anything else (an assignee) at the end. */
+declare function KanbanItemFooter({ className, ...rest }: KanbanItemFooterProps): import("react/jsx-runtime").JSX.Element;
+declare namespace KanbanItemFooter {
+    var displayName: string;
+}
+export type KanbanItemCountProps = React.HTMLAttributes<HTMLSpanElement> & {
+    ref?: React.Ref<HTMLSpanElement>;
+};
+/** A small muted counter with an icon (comments, attachments, subtasks). */
+declare function KanbanItemCount({ className, ...rest }: KanbanItemCountProps): import("react/jsx-runtime").JSX.Element;
+declare namespace KanbanItemCount {
+    var displayName: string;
+}
+export declare const Kanban: {
+    Root: typeof KanbanRoot;
+    Item: typeof KanbanItem;
+    ItemTitle: typeof KanbanItemTitle;
+    ItemDescription: typeof KanbanItemDescription;
+    ItemBadges: typeof KanbanItemBadges;
+    ItemFooter: typeof KanbanItemFooter;
+    ItemCount: typeof KanbanItemCount;
+};
+export {};

package/dist/components/modal/Modal.d.ts

@@ -12,7 +12,10 @@ export type ModalRootProps = {
     onOpenChange?: (open: boolean) => void;
     /** Escape closes the dialog. Default `true`. */
     closeOnEscape?: boolean;
-    /** A click on the scrim closes the dialog. Default `true`; turn it off for destructive confirms. */
+    /**
+     * A click on the scrim (or, on a narrow viewport, a swipe down) closes the dialog. Default
+     * `true`; turn it off for destructive confirms.
+     */
     closeOnOutsideClick?: boolean;
     /** Enter clicks the action wrapped in `Modal.Confirm`. Default `true`. */
     confirmOnEnter?: boolean;
@@ -28,7 +31,7 @@ declare namespace ModalRoot {
 export type ModalContentProps = React.HTMLAttributes<HTMLDivElement> & {
     /**
      * Dialog width: `s` 440 · `m` 560 · `l` 720 · `xl` 960. Below 640px of viewport the dialog is
-     * always a full-width bottom sheet.
+     * always a full-width bottom sheet with a grab handle.
      */
     size?: Exclude<ControlSize, "xs">;
     /** Portal target. Default `document.body`. */

package/dist/components/page-toolbar/PageToolbar.d.ts

@@ -0,0 +1,53 @@
+import * as React from "react";
+type DivProps = React.HTMLAttributes<HTMLDivElement> & {
+    ref?: React.Ref<HTMLDivElement>;
+};
+export type PageToolbarRootProps = DivProps;
+/**
+ * The panel at the top of a page: sections, tools, view options and the primary action. It lays
+ * itself out from its own width — one row when wide, exactly two rows when narrow — so the slots
+ * keep fixed places at any width. Parts may be left out; the JSX order is the Tab order.
+ */
+declare function PageToolbarRoot({ className, children, ref, ...rest }: PageToolbarRootProps): import("react/jsx-runtime").JSX.Element;
+declare namespace PageToolbarRoot {
+    var displayName: string;
+}
+export type PageToolbarSectionsProps = DivProps;
+/** Sections of the page — a `fullWidth` SegmentedControl; top row, stretches when narrow. */
+declare function PageToolbarSections({ className, ...rest }: PageToolbarSectionsProps): import("react/jsx-runtime").JSX.Element;
+declare namespace PageToolbarSections {
+    var displayName: string;
+}
+export type PageToolbarToolsProps = DivProps;
+/** Filter button and search (`SmartFilter.Toolbar`): takes the free space of its row. */
+declare function PageToolbarTools({ className, ...rest }: PageToolbarToolsProps): import("react/jsx-runtime").JSX.Element;
+declare namespace PageToolbarTools {
+    var displayName: string;
+}
+export type PageToolbarViewProps = DivProps;
+/** How the data is shown: period, table / cards, columns. Sized by content; alone in a row, its controls share the row. */
+declare function PageToolbarView({ className, ...rest }: PageToolbarViewProps): import("react/jsx-runtime").JSX.Element;
+declare namespace PageToolbarView {
+    var displayName: string;
+}
+export type PageToolbarActionsProps = DivProps;
+/** The primary action of the page: the top row's end at every width, never wraps down. */
+declare function PageToolbarActions({ className, ...rest }: PageToolbarActionsProps): import("react/jsx-runtime").JSX.Element;
+declare namespace PageToolbarActions {
+    var displayName: string;
+}
+export type PageToolbarChipsProps = DivProps;
+/** Active filters (`SmartFilter.Chips`) in their own row under the panel; the row disappears when empty. */
+declare function PageToolbarChips({ className, ...rest }: PageToolbarChipsProps): import("react/jsx-runtime").JSX.Element;
+declare namespace PageToolbarChips {
+    var displayName: string;
+}
+export declare const PageToolbar: {
+    Root: typeof PageToolbarRoot;
+    Sections: typeof PageToolbarSections;
+    Tools: typeof PageToolbarTools;
+    View: typeof PageToolbarView;
+    Actions: typeof PageToolbarActions;
+    Chips: typeof PageToolbarChips;
+};
+export {};

package/dist/components/segmented-control/SegmentedControl.d.ts

@@ -6,7 +6,10 @@ export type SegmentedControlRootProps = Omit<React.HTMLAttributes<HTMLDivElement
     onValueChange?: (value: string) => void;
     disabled?: boolean;
     size?: ControlSize;
-    /** Stretch to the container width; segments share it equally and truncate their labels. */
+    /**
+     * Stretch to the container width. Single-line segments tend to equal widths but never get narrower
+     * than their label; when they do not fit, the row scrolls.
+     */
     fullWidth?: boolean;
     ref?: React.Ref<HTMLDivElement>;
 };
@@ -49,7 +52,7 @@ export type SegmentedControlLabelProps = {
     className?: string;
     ref?: React.Ref<HTMLSpanElement>;
 } & Omit<React.HTMLAttributes<HTMLSpanElement>, "children">;
-/** Segment title; truncates with an ellipsis. Plain text children are wrapped automatically. */
+/** Segment title on one line; never truncated. Plain text children are wrapped automatically. */
 declare function SegmentedControlLabel({ children, className, ...rest }: SegmentedControlLabelProps): import("react/jsx-runtime").JSX.Element;
 declare namespace SegmentedControlLabel {
     var displayName: string;

package/dist/components/tabs/Tabs.d.ts

@@ -14,9 +14,12 @@ export type TabsRootProps = Omit<React.HTMLAttributes<HTMLDivElement>, "defaultV
     size?: ControlSize;
     /** Text and icon colour of the active tab. Default `neutral`: primary text, accent icon. */
     tone?: "neutral" | "accent";
-    /** Horizontal tabs share the list width. Default `true`; `false` sizes each tab to its content. */
+    /**
+     * Horizontal tabs fill the list and tend to equal widths, never narrower than their content.
+     * Default `true`; `false` sizes each tab to its content.
+     */
     fullWidth?: boolean;
-    /** Narrowest a horizontal tab with a label gets before the list scrolls (px or a CSS length). */
+    /** Narrowest a horizontal tab with a label gets (px or a CSS length); never below its content. */
     minItemWidth?: number | string;
     /** Widest a horizontal tab gets (px or a CSS length); a longer label ends with an ellipsis. */
     maxItemWidth?: number | string;

package/dist/hooks/useEdgeOverflow.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+export type EdgeOverflow = {
+    start: boolean;
+    end: boolean;
+};
+/**
+ * Tracks whether a scroll region hides content before / after its visible part along one axis
+ * (`ScrollContainer` `fade`, the DataTable edge cue). Measured at most once per frame on scroll,
+ * on resize of the region or any child, and when children are added. RTL-aware: the start is the
+ * inline start of the region.
+ */
+export declare function useEdgeOverflow(ref: React.RefObject<HTMLElement | null>, enabled: boolean, horizontal: boolean): EdgeOverflow;

package/dist/hooks/useMediaQuery.d.ts

@@ -0,0 +1,7 @@
+/** Viewport below the first breakpoint (foundation §9): overlays become bottom sheets. */
+export declare const COMPACT_QUERY = "(max-width: 639px)";
+/**
+ * Whether a media query matches, kept in sync with the viewport. `false` on the server, while
+ * `enabled` is off, and where `matchMedia` is missing.
+ */
+export declare function useMediaQuery(query: string, enabled?: boolean): boolean;

package/dist/hooks/useSwipeDismiss.d.ts

@@ -0,0 +1,34 @@
+import * as React from "react";
+/** The direction a panel leaves in: toward the screen edge it came from. */
+export type SwipeDirection = "down" | "left" | "right";
+export type UseSwipeDismissOptions = {
+    enabled: boolean;
+    direction: SwipeDirection;
+    onDismiss: () => void;
+    /** Selector of the zones a drag starts from by any pointer: the grab handle, the header. */
+    handle: string;
+    /**
+     * A touch drag may also start anywhere else in the panel (side drawers, whose content scrolls
+     * across the swipe axis). Mouse and pen drags start from `handle` only, so text stays selectable.
+     */
+    touchAnywhere?: boolean;
+    /**
+     * How far out the panel is, 0 (at rest) … 1 (off its edge), on every move and on release (0 back,
+     * 1 out) — for parts that follow the drag, such as the scrim's opacity.
+     */
+    onProgress?: (progress: number) => void;
+};
+/** The custom property the panel CSS maps onto its own axis (`transform`). */
+export declare const SWIPE_OFFSET_VAR = "--swipe-offset";
+/**
+ * Swipe-to-close for a panel at a screen edge (Drawer, a bottom sheet). Attach `onPointerDown` to
+ * the panel: a drag from `handle` (or, with `touchAnywhere`, any touch) along the closing axis moves
+ * the panel with the pointer through `--swipe-offset` and `data-swiping`, which its CSS maps onto
+ * `transform`. On release the panel closes past 30% of its size or on a flick — gliding the rest of
+ * the way out from the release point (`data-swipe-dismissed`) — otherwise it glides back;
+ * `onProgress` follows along. A drag across the axis is left to scrolling. The gesture is an extra
+ * way out: the panel keeps its close button and Escape (WCAG 2.5.7).
+ */
+export declare function useSwipeDismiss({ enabled, direction, onDismiss, handle, touchAnywhere, onProgress, }: UseSwipeDismissOptions): {
+    onPointerDown: (event: React.PointerEvent<HTMLElement>) => void;
+};