@servicetitan/anvil2 3.16.1 → 3.17.0

package/dist/src/beta/components/Table/DataTable/DataTable.d.ts

@@ -1,8 +1,8 @@
 import { ComponentPropsWithoutRef, forwardRef, Ref, ReactNode } from 'react';
 import { DataAttributes, LayoutUtilProps } from '../../../../types';
 import { ColumnDef, CustomTableFooterCellProps, TableRow } from '../types';
-import { DataTableCacheOptions, DataTableEmptyState, DataTablePaginationConfig, DataTableRef, SortedColumn } from './types';
-export type { DataTableCacheOptions, DataTableRef, DataTableEmptyState, SortedColumn, };
+import { DataTableBulkAction, DataTableBulkActions, DataTableBulkMenuAction, DataTableBulkMenuItem, DataTableBulkPrimaryAction, DataTableBulkSecondaryAction, DataTableBulkSelection, DataTableCacheOptions, DataTableColumnEditing, DataTableColumnPref, DataTableEditColumnsSection, DataTableEmptyState, DataTablePaginationConfig, DataTableFilters, DataTableRef, DataTableRowAdd, DataTableToolbarAction, DataTableTools, SortedColumn } from './types';
+export type { DataTableBulkAction, DataTableBulkActions, DataTableBulkMenuAction, DataTableBulkMenuItem, DataTableBulkPrimaryAction, DataTableBulkSecondaryAction, DataTableBulkSelection, DataTableCacheOptions, DataTableFilters, DataTableColumnEditing, DataTableColumnPref, DataTableEditColumnsSection, DataTableRef, DataTableRowAdd, DataTableEmptyState, DataTableToolbarAction, DataTableTools, SortedColumn, };
 export type DataTableRowData = object;
 /**
  * @extends LayoutUtilProps
@@ -148,11 +148,38 @@ export type DataTableProps<T extends DataTableRowData> = LayoutUtilProps & Compo
      * appear stale when external state changes.
      */
     getRowVersion?: (row: T) => unknown;
+    /**
+     * Filter bar rendered above the table. See {@link DataTableFilters}.
+     */
+    filters?: DataTableFilters;
+    /**
+     * Toolbar rendered to the right of the filter bar. See
+     * {@link DataTableTools}.
+     */
+    tools?: DataTableTools;
+    /**
+     * {@link DataTableBulkActions} shown in a bar above the table while rows
+     * are selected; the bar replaces the filter bar and toolbar until the
+     * selection clears. Requires `isSelectable`.
+     */
+    bulkActions?: DataTableBulkActions<T>;
+    /**
+     * Adds an Edit Columns button at the end of the toolbar (unless `hideButton`). Its drawer lets
+     * users reorder, hide, and pin columns, then reports the result through
+     * `onLayoutChange`. Feed that layout back in; DataTable applies it to
+     * `columns` and doesn't store it.
+     */
+    columnEditing?: DataTableColumnEditing;
+    /**
+     * Add row button in a toolbar below the table. See {@link DataTableRowAdd}.
+     */
+    rowAdd?: DataTableRowAdd;
 };
 declare function DataTableInner<T extends DataTableRowData>(props: DataTableProps<T>, ref: Ref<DataTableRef>): import("react/jsx-runtime").JSX.Element;
 /**
- * Sortable, pageable data grid with optional selection, expansion, pinning,
- * and cell editing. Attach a {@link DataTableRef} to `refresh` or `clearCache`.
+ * Sortable, pageable data grid with optional selection, bulk actions,
+ * expansion, pinning, and cell editing. Attach a {@link DataTableRef} to
+ * `refresh`, `clearCache`, or `clearSelection`.
  */
 export declare const DataTable: (<T extends DataTableRowData>(props: DataTableProps<T> & {
     ref?: Ref<DataTableRef>;

package/dist/src/beta/components/Table/DataTable/DataTableEditColumnsDrawer.d.ts

@@ -0,0 +1,18 @@
+import { DataTableEditColumnsSection } from './types';
+export type DataTableEditColumnsDrawerProps = {
+    /** Controls whether the drawer is shown. */
+    open: boolean;
+    /** Requests that the controlling page close the drawer. */
+    onClose: () => void;
+    /**
+     * One titled section per table. Apply reports only the sections the user
+     * changed; Reset Defaults resets every section. Memoize the array.
+     */
+    sections: DataTableEditColumnsSection[];
+};
+/**
+ * Edit Columns drawer for one page-level trigger that covers several tables.
+ * Set `columnEditing.hideButton` on each table so only this drawer's trigger
+ * shows. For a single table, `columnEditing` alone is enough.
+ */
+export declare function DataTableEditColumnsDrawer({ open, onClose, sections, }: DataTableEditColumnsDrawerProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/DataTable/index.d.ts

@@ -1 +1,2 @@
 export * from './DataTable';
+export * from './DataTableEditColumnsDrawer';

package/dist/src/beta/components/Table/DataTable/internal/DataTableAddRow.d.ts

@@ -0,0 +1,11 @@
+import { DataTableRowAdd } from '../types';
+/**
+ * Duplicate of the toolbar button, centered under the empty state. Rendered
+ * outside the grid element because the button is not a row or gridcell.
+ */
+export declare function DataTableEmptyAddRow({ rowAdd }: {
+    rowAdd: DataTableRowAdd;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function DataTableAddRow({ rowAdd }: {
+    rowAdd: DataTableRowAdd;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/DataTable/internal/DataTableBulkActionBar.d.ts

@@ -0,0 +1,23 @@
+import { RefObject } from 'react';
+import { DataTableBulkActions, DataTableBulkSelection } from '../types';
+export type DataTableBulkActionBarProps<T> = {
+    actions: DataTableBulkActions<T>;
+    /** Rows counted as selected; the total row count in "all" mode. */
+    selectedCount: number;
+    /** Shows "Select all N items" when set. */
+    selectAllCount?: number;
+    /** Some rows can't be selected, so the button reads "Select all N items of N". */
+    hasUnselectableRows: boolean;
+    onSelectAll: () => void;
+    onCancel: () => void;
+    getSelection: () => DataTableBulkSelection<T>;
+    /** Runs after an action completes without asking to keep the selection. */
+    onActionComplete: () => void;
+    tableRef: RefObject<HTMLDivElement>;
+};
+/**
+ * Selection count, select-all, cancel, and consumer actions shown above the
+ * table while rows are selected. The live region stays mounted so the first
+ * selection is announced too.
+ */
+export declare function DataTableBulkActionBar<T>({ actions, selectedCount, selectAllCount, hasUnselectableRows, onSelectAll, onCancel, getSelection, onActionComplete, tableRef, }: DataTableBulkActionBarProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/DataTable/internal/DataTableFilterToolbar.d.ts

@@ -0,0 +1,12 @@
+import { Filter } from '../../../FilterBar';
+import { DataTableFilters, DataTableTools } from '../types';
+import { EditColumnsSection } from './columnEditing/EditColumnsDrawer';
+type DataTableFilterToolbarProps = {
+    filters?: DataTableFilters;
+    tools?: DataTableTools;
+    columnEditing?: EditColumnsSection;
+    /** Wraps `filters.onChange` with DataTable's page and cache reset. */
+    onFilterChange: (filters: Filter[]) => void;
+};
+export declare function DataTableFilterToolbar({ filters, tools, onFilterChange, columnEditing, }: DataTableFilterToolbarProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/beta/components/Table/DataTable/internal/columnEditing/EditColumnsDrawer.d.ts

@@ -0,0 +1,29 @@
+import { DataTableColumnPref } from '../../types';
+/** One table's columns in an {@link EditColumnsDrawer}. */
+export type EditColumnsSection = {
+    /** Unique within the drawer; namespaces the drag zones. */
+    id: string;
+    /** Heading shown above the section when the drawer has more than one. */
+    title?: string;
+    /** True when `alwaysVisible` or right-pinned columns keep the table non-empty. */
+    hasFixedColumns?: boolean;
+    /** Ids of `alwaysVisible` columns, whose hide button is disabled. */
+    alwaysVisibleIds?: string[];
+    /** Editable columns' header labels by id. */
+    labels: Record<string, string>;
+    layout: DataTableColumnPref[];
+    onApply: (layout: DataTableColumnPref[]) => void;
+    onReset: () => void;
+};
+type EditColumnsDrawerProps = {
+    open: boolean;
+    onClose: () => void;
+    sections: EditColumnsSection[];
+};
+/**
+ * Edits stay in local drafts until Apply, which reports only the sections that
+ * changed. The drafts are rebuilt only when the drawer opens, so a layout
+ * change from outside mid-edit doesn't wipe them.
+ */
+export declare function EditColumnsDrawer({ open, onClose, sections, }: EditColumnsDrawerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/beta/components/Table/DataTable/internal/columnEditing/columnLayout.d.ts

@@ -0,0 +1,43 @@
+import { DndSortChangeEvent } from '../../../../../../components/DndSort';
+import { ColumnDef } from '../../../types';
+import { DataTableColumnLike, DataTableColumnPref } from '../../types';
+/** Columns the drawer can move: everything but those pinned right. */
+export declare function isEditableColumn(column: DataTableColumnLike): boolean;
+export declare function getColumnLabel(column: DataTableColumnLike): string;
+/** Ids of the columns that render a header cell of their own, descending into groups. */
+export declare function getLeafColumnIds<T>(columns: ColumnDef<T>[]): Set<string>;
+/** Layout implied by the `columns` prop: its order, all visible, left-pinned as declared. */
+export declare function getDefaultLayout(columns: DataTableColumnLike[]): DataTableColumnPref[];
+/**
+ * Reconciles a layout with the editable columns: unknown and duplicate ids
+ * drop out, omitted columns append as visible with their declared left pin,
+ * an `alwaysVisible` column is never hidden, and a hidden column is never
+ * pinned.
+ */
+export declare function mergeLayout(layout: readonly DataTableColumnPref[], editable: readonly DataTableColumnLike[]): DataTableColumnPref[];
+/**
+ * Returns `columns` reordered, filtered, and pinned by `layout`. Columns the
+ * drawer can't edit keep their slot; hidden columns are removed.
+ */
+export declare function applyColumnLayout<T>(columns: ColumnDef<T>[], layout: readonly DataTableColumnPref[]): ColumnDef<T>[];
+declare const PINNED = "pinned";
+declare const VISIBLE = "visible";
+declare const HIDDEN = "hidden";
+export type ColumnBucketName = typeof PINNED | typeof VISIBLE | typeof HIDDEN;
+/** Column ids grouped by where they sit in the drawer. */
+export type ColumnBuckets = Record<ColumnBucketName, string[]>;
+export declare function toBuckets(layout: readonly DataTableColumnPref[]): ColumnBuckets;
+export declare function toLayout(buckets: ColumnBuckets): DataTableColumnPref[];
+/** Applies a drop within one zone. Pinned and visible zones never exchange cards. */
+export declare function reorderBucket(prev: ColumnBuckets, bucket: typeof PINNED | typeof VISIBLE, event: DndSortChangeEvent): ColumnBuckets;
+/** Pins a visible column (to the end of the pinned list) or unpins one (to the top of visible). */
+export declare function togglePinnedIn(prev: ColumnBuckets, id: string): ColumnBuckets;
+/**
+ * True when hiding one more column would leave the table with none showing.
+ * `hasFixedColumns` is true when columns outside the drawer (`alwaysVisible`
+ * or pinned right) keep the table populated regardless.
+ */
+export declare function isLastShown(buckets: ColumnBuckets, hasFixedColumns?: boolean): boolean;
+/** Hides or shows an unpinned column; never hides the last one showing. */
+export declare function toggleVisibleIn(prev: ColumnBuckets, id: string, hasFixedColumns?: boolean): ColumnBuckets;
+export {};

package/dist/src/beta/components/Table/DataTable/internal/columnEditing/toEditColumnsSection.d.ts

@@ -0,0 +1,7 @@
+import { DataTableEditColumnsSection } from '../../types';
+import { EditColumnsSection } from './EditColumnsDrawer';
+/**
+ * Reduces a table's `columns` and stored layout to what the drawer edits.
+ * Reset reports the layout implied by `columns`.
+ */
+export declare function toEditColumnsSection({ title, columns, layout, onLayoutChange }: DataTableEditColumnsSection, id: string): EditColumnsSection;

package/dist/src/beta/components/Table/DataTable/parts.d.ts

@@ -13,4 +13,21 @@ export declare const PARTS: {
     readonly expandAllButton: "expand-all-button";
     readonly resizeHandle: "resize-handle";
     readonly editableInput: "editable-input";
+    readonly bulkActionBar: "bulk-action-bar";
+    readonly bulkSelectAllButton: "bulk-select-all-button";
+    readonly bulkCancelButton: "bulk-cancel-button";
+    readonly bulkActionsMenuButton: "bulk-actions-menu-button";
+    readonly bulkActionButton: "bulk-action-button";
+    readonly bulkActionMenuItem: "bulk-action-menu-item";
+    readonly rowAddButton: "row-add-button";
+    readonly editColumnsButton: "edit-columns-button";
+    readonly editColumnsDrawer: "edit-columns-drawer";
+    readonly columnsSection: "columns-section";
+    readonly columnCard: "column-card";
+    readonly pinColumnButton: "pin-column-button";
+    readonly hideColumnButton: "hide-column-button";
+    readonly resetColumnsButton: "reset-columns-button";
+    readonly applyButton: "apply-button";
+    readonly cancelButton: "cancel-button";
+    readonly confirmButton: "confirm-button";
 };

package/dist/src/beta/components/Table/DataTable/types.d.ts

@@ -1,6 +1,10 @@
 import { ReactNode } from 'react';
 import { TableRow } from '../types';
-import { Svg } from '../../../../types';
+import { DataAttributes, Svg } from '../../../../types';
+import { ButtonProps } from '../../../../components/Button';
+import { ToolbarButtonProps } from '../../Toolbar';
+import { ToolbarSize } from '../../Toolbar/types';
+import { Filter } from '../../FilterBar';
 /**
  * Single-column sort. DataTable only applies `sorting[0]`.
  */
@@ -25,6 +29,11 @@ export type DataTableEmptyState = {
     };
     /** Rendered under the illustration. */
     content?: ReactNode;
+    /**
+     * Repeats the `rowAdd` button under `content`, for tables that start empty.
+     * Does nothing without `rowAdd`.
+     */
+    includeAddRow?: boolean;
 };
 /**
  * `loadPageData` page cache. Hits restore a page without calling the loader.
@@ -129,7 +138,96 @@ export type DataTableCursorPaginationConfig<T> = DataTablePaginationBaseConfig<T
  */
 export type DataTablePaginationConfig<T> = DataTableOffsetPaginationConfig<T> | DataTableCursorPaginationConfig<T>;
 /**
- * Imperative handle: refetch the current loader, or drop cached pages.
+ * What a bulk action applies to. `"rows"` lists the checked row ids as
+ * strings, the same form as `onSelectRow` (numeric ids arrive stringified).
+ * `"all"` means every selectable row across pages, including rows that have
+ * not loaded — rows rejected by `isSelectable` and rows in `readOnlyRowIds`
+ * are excluded, so the backend must apply the same rules. Its
+ * `selectedRowCount` is the count the bar shows, sub-rows included.
+ */
+export type DataTableBulkSelection<T> = {
+    mode: "rows";
+    rowIds: TableRow<T>["id"][];
+} | {
+    mode: "all";
+    selectedRowCount: number;
+};
+/**
+ * A bulk action button, or a menu item when nested under `items`.
+ */
+export type DataTableBulkAction<T> = Omit<ButtonProps, "appearance" | "onClick" | "loading" | "children"> & {
+    /**
+     * Visible button text, or menu-item text when nested under `items`. A
+     * function receives the selected count (the total after "Select all N
+     * items"), e.g. for singular and plural wording.
+     */
+    label: string | ((selectedCount: number) => string);
+    /**
+     * Runs with the current {@link DataTableBulkSelection}. Selection clears
+     * once it returns or resolves. Return or resolve `false` to keep rows
+     * selected (e.g. while a confirmation dialog is open); a rejected promise
+     * also keeps them selected. The button shows a spinner while it is pending.
+     */
+    onClick: (selection: DataTableBulkSelection<T>) => void | boolean | Promise<void | boolean>;
+};
+/**
+ * The bar's primary button.
+ */
+export type DataTableBulkPrimaryAction<T> = DataTableBulkAction<T> & {
+    /** Defaults to `"primary"`. */
+    appearance?: "primary" | "danger";
+};
+/**
+ * A primary button that opens a menu of actions instead of running one.
+ */
+export type DataTableBulkMenuAction<T> = Omit<DataTableBulkPrimaryAction<T>, "onClick"> & {
+    /** Menu items. The button runs no handler of its own. */
+    items: DataTableBulkMenuItem<T>[];
+};
+/**
+ * An item in a primary action's menu. `data-*` attributes reach the item.
+ */
+export type DataTableBulkMenuItem<T> = DataAttributes & Pick<DataTableBulkAction<T>, "label" | "onClick"> & {
+    /** Leading icon. */
+    icon?: Svg;
+    /** Prevents selection. Defaults to `false`. */
+    disabled?: boolean;
+};
+/**
+ * A secondary button in the bar.
+ */
+export type DataTableBulkSecondaryAction<T> = DataTableBulkAction<T> & {
+    /** Defaults to `"secondary"`. */
+    appearance?: "secondary" | "danger-secondary";
+};
+/**
+ * Actions shown in the bulk action bar while rows are selected.
+ */
+export type DataTableBulkActions<T> = {
+    /** Primary button. Pass `items` to open a menu of actions instead. */
+    primary?: DataTableBulkPrimaryAction<T> | DataTableBulkMenuAction<T>;
+    /**
+     * Button before the primary one. For more actions, pass `items` to the
+     * primary action instead.
+     */
+    secondary?: DataTableBulkSecondaryAction<T>;
+    /**
+     * Shows a "Select all N items" button that selects rows across pages. Only
+     * shown with offset pagination when the total exceeds one page.
+     * @default false
+     */
+    selectAll?: boolean;
+    /**
+     * Rows "Select all" selects when pages come from `loadPageData`, counting
+     * sub-rows and leaving out rows that can't be selected; the table can't see
+     * rows that haven't loaded. Defaults to `pagination.totalRowCount`. With
+     * `data`, the table counts the selectable rows itself.
+     */
+    selectableRowCount?: number;
+};
+/**
+ * Imperative handle: refetch the current loader, drop cached pages, or clear
+ * the selection.
  */
 export type DataTableRef = {
     /**
@@ -143,5 +241,150 @@ export type DataTableRef = {
      * `refresh` or a cache-invalidating input changes.
      */
     clearCache: () => void;
+    /**
+     * Clears the selection, including a "Select all N items" selection. Use it
+     * after a bulk action returned `false` to keep rows selected, e.g. once a
+     * confirmation dialog is confirmed.
+     */
+    clearSelection: () => void;
+};
+/** One column's place in a {@link DataTableColumnEditing} layout. */
+export type DataTableColumnPref = {
+    /** Id of a top-level column in `columns`. */
+    id: string;
+    /** Controls rendering while retaining the column in the layout so it can be restored. */
+    visible: boolean;
+    /** Pins the column to the left. Hidden columns are never pinned. */
+    pinned: boolean;
+};
+/**
+ * Turns on the Edit Columns button and drawer. The consumer owns the layout:
+ * DataTable applies it to `columns` and reports Apply and Reset Defaults
+ * through `onLayoutChange`.
+ */
+export type DataTableColumnEditing = {
+    /**
+     * Current order, visibility, and pinning: pinned columns first, then the
+     * rest, each in list order, with hidden columns left out. Ids that match no
+     * editable column and repeated ids are ignored; columns missing from the
+     * list are appended as visible, keeping a declared `pinned: "left"`, so a
+     * stored layout survives column changes.
+     */
+    layout: DataTableColumnPref[];
+    /**
+     * Fires with the full layout when the user applies their edits, and with
+     * the layout implied by `columns` when they reset to defaults.
+     */
+    onLayoutChange: (layout: DataTableColumnPref[]) => void;
+    /**
+     * Hides the toolbar button while the layout still applies, for a page that
+     * opens one {@link DataTableEditColumnsDrawer} across several tables.
+     * @default false
+     */
+    hideButton?: boolean;
+};
+/** The parts of a column def the drawer reads, so tables of any row type fit one section list. */
+export type DataTableColumnLike = {
+    id: string | number | symbol;
+    pinned?: "left" | "right";
+    alwaysVisible?: boolean;
+    header?: {
+        label: string;
+    };
+    headerLabel?: string;
+};
+/** One table in a {@link DataTableEditColumnsDrawer}. */
+export type DataTableEditColumnsSection = {
+    /** Heading shown above the section when the drawer has more than one. */
+    title?: string;
+    /** The same `columns` the table receives. */
+    columns: DataTableColumnLike[];
+    /**
+     * Current order, visibility, and pinning for this table's drawer-editable
+     * columns: pinned columns first, then the rest, each in list order, with
+     * hidden columns left out. Ids that match no editable column and repeated
+     * ids are ignored; columns missing from the list are appended as visible,
+     * keeping a declared `pinned: "left"`.
+     */
+    layout: DataTableColumnPref[];
+    /** Fires with the new layout on Apply, or the default layout on Reset. */
+    onLayoutChange: (layout: DataTableColumnPref[]) => void;
+};
+/**
+ * A button in the DataTable toolbar. Takes the props of a toolbar button:
+ * a text label as `children`, or an `icon` with a required `aria-label`.
+ */
+export type DataTableToolbarAction = ToolbarButtonProps & {
+    /** Stable identity for the button. Not forwarded to the DOM. */
+    id: string;
+};
+/**
+ * Filter bar configuration for DataTable. DataTable does not filter rows
+ * itself: apply changes from `onChange` to `data` or to your `loadPageData`
+ * request.
+ */
+export type DataTableFilters = {
+    /**
+     * Filter definitions rendered as a filter bar above the table. Memoize the
+     * array; a new identity re-syncs the bar and discards in-progress input.
+     */
+    items: Filter[];
+    /**
+     * Fires with the full filter list after a filter commit. Any change also
+     * returns a paginated table to its first page and, with `loadPageData`,
+     * clears the page cache and reloads, so the loader sees the new filters.
+     */
+    onChange: (filters: Filter[]) => void;
+    /**
+     * Delays inline commits for filters with an Apply affordance. Filters
+     * without one still commit immediately; the drawer always batches changes.
+     * @default false
+     */
+    controlled?: boolean;
+    /**
+     * Size of the filter bar controls.
+     * @default "medium"
+     */
+    size?: ToolbarSize;
+};
+/**
+ * Toolbar configuration for DataTable, rendered to the right of the filter
+ * bar. Works without `filters`.
+ */
+export type DataTableTools = {
+    /**
+     * Buttons in the toolbar, e.g. Export. Only Anvil2 buttons are accepted;
+     * arbitrary nodes are not.
+     */
+    actions: DataTableToolbarAction[];
+    /**
+     * Size of the toolbar controls.
+     * @default "medium"
+     */
+    size?: ToolbarSize;
+};
+/**
+ * Add row button in a toolbar below the table. DataTable only fires
+ * `onAddRow`: the page owns the flow, such as a dialog or a takeover, and
+ * must update `data` when it finishes, or call {@link DataTableRef} `refresh`
+ * for a table that loads rows with `pagination.loadPageData`.
+ */
+export type DataTableRowAdd = {
+    /** Fires when the Add button is clicked. */
+    onAddRow: () => void;
+    /**
+     * Label of the Add button.
+     * @default "Add row"
+     */
+    addRowLabel?: string;
+    /** Disables the Add button. */
+    disabled?: boolean;
+    /** Shows the Add button as busy, e.g. while an external check runs. */
+    loading?: boolean;
+    /**
+     * Size of the toolbar controls.
+     * @default "medium"
+     */
+    size?: ToolbarSize;
 };
 export {};

package/dist/src/beta/components/Table/types.d.ts

@@ -519,6 +519,12 @@ export type ColumnBaseDef = ColumnHeaderConfig & {
     defaultWidth?: number;
     /** Keeps the column against the chosen edge while horizontally scrolling. */
     pinned?: "left" | "right";
+    /**
+     * Disables the column's hide button in the Edit Columns drawer. It is still
+     * listed there and can be reordered or pinned. Only applies when DataTable
+     * has `columnEditing`.
+     */
+    alwaysVisible?: boolean;
     /** Shows a pointer-driven resize handle. */
     resizable?: boolean;
 };

package/dist/src/components/DrillDown/DrillDownHeader.d.ts

@@ -1,11 +1,20 @@
 import { PassThroughPropsWithRef } from '../../types';
 import { TextProps } from '../Text';
+import { DrawerHeaderAction } from '../Drawer/DrawerHeader';
+/** Command shown in `DrillDown.Header`'s overflow menu. Same shape as {@link DrawerHeaderAction}. */
+export type DrillDownHeaderAction = DrawerHeaderAction;
 export type DrillDownHeaderProps = PassThroughPropsWithRef<"header"> & {
     /** Heading element for the title. Defaults to `h1`. */
     el?: TextProps["el"];
+    /**
+     * Commands placed in an overflow menu before the close control. Belong to
+     * this screen only; the host Drawer's actions are not inherited.
+     */
+    actions?: DrillDownHeaderAction[];
 };
 /**
- * Title row with a back control. Close appears when this screen registered
- * `onClose`. Children are the heading text.
+ * Title row with a back control. An overflow menu appears when `actions` is
+ * non-empty, and Close appears when this screen registered `onClose`.
+ * Children are the heading text.
  */
 export declare const DrillDownHeader: import('react').ForwardRefExoticComponent<Omit<DrillDownHeaderProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/src/components/DrillDown/index.d.ts

@@ -1,5 +1,5 @@
 export { DrillDown as default, DrillDown, type DrillDownProps, } from './DrillDown';
-export { DrillDownHeader, type DrillDownHeaderProps } from './DrillDownHeader';
+export { DrillDownHeader, type DrillDownHeaderAction, type DrillDownHeaderProps, } from './DrillDownHeader';
 export { DrillDownContent, type DrillDownContentProps, } from './DrillDownContent';
 export { DrillDownFooter, type DrillDownFooterProps } from './DrillDownFooter';
 export { DrillDownNextButton, type DrillDownNextButtonProps, } from './DrillDownNextButton';

package/dist/src/components/DrillDown/internal/DrillDownContext.d.ts

@@ -1,5 +1,9 @@
 import { Dispatch, SetStateAction } from 'react';
+/** Component that owns the DrillDown stack. */
+export type DrillDownHost = "dialog" | "drawer" | "panel";
 export type DrillDownContextProps = {
+    /** Owning host. `DrillDown.Header` drops `actions` inside a `"dialog"`. */
+    host?: DrillDownHost;
     /** Active screen, or `undefined` when the stack is closed. */
     index?: number;
     setIndex?: (index: number | undefined) => void;
@@ -8,8 +12,9 @@ export type DrillDownContextProps = {
     /** Occupancy counts by index; a missing slot means `next()` should close. */
     registeredIndices?: number[];
     setRegisteredIndices?: Dispatch<SetStateAction<number[] | undefined>>;
-    onClose?: (() => void)[];
-    setOnClose?: (fn: () => void, index: number) => void;
+    onClose?: ((() => void) | undefined)[];
+    /** Registers a screen's Close handler; `undefined` clears that index. */
+    setOnClose?: (fn: (() => void) | undefined, index: number) => void;
     /** When `false`, no screen mounts (host is closing or unopened). */
     hostIsInteractive?: boolean;
     setHostTrigger?: (element: HTMLElement | null) => void;

package/dist/src/components/DrillDown/internal/useDrillDownContextState.d.ts

@@ -1,19 +1,22 @@
+import { DrillDownHost } from './DrillDownContext';
 type useDrillDownContextStateParams = {
     /**
      * Screen opened by the first `next()` from a closed stack, and restored when
      * the host closes after a drilldown session. Defaults to `0`.
      */
     defaultDrillDownIndex?: number;
+    host: DrillDownHost;
 };
-export declare function useDrillDownContextState({ defaultDrillDownIndex, }: useDrillDownContextStateParams): {
+export declare function useDrillDownContextState({ defaultDrillDownIndex, host, }: useDrillDownContextStateParams): {
+    host: DrillDownHost;
     index: number | undefined;
     setIndex: (index: number | undefined) => void;
     back: () => void;
     next: () => void;
     registeredIndices: number[] | undefined;
     setRegisteredIndices: import('react').Dispatch<import('react').SetStateAction<number[] | undefined>>;
-    onClose: (() => void)[];
-    setOnClose: (fn: () => void, index: number) => void;
+    onClose: ((() => void) | undefined)[];
+    setOnClose: (fn: (() => void) | undefined, index: number) => void;
     hostIsInteractive: boolean;
     setHostTrigger: (element: HTMLElement | null) => void;
     onHostClose: () => void;

package/dist/src/hooks/usePrefersReducedMotion/index.d.ts

@@ -1 +1,3 @@
+export { prefersReducedMotion } from './prefersReducedMotion';
 export * from './usePrefersReducedMotion';
+export * from './useReducedMotion';

package/dist/src/hooks/usePrefersReducedMotion/prefersReducedMotion.d.ts

@@ -0,0 +1,6 @@
+export declare const PREFERS_REDUCED_MOTION_QUERY = "(prefers-reduced-motion: reduce)";
+/**
+ * One-shot read of the OS reduced-motion setting for non-React code.
+ * Returns `false` when `matchMedia` is unavailable.
+ */
+export declare const prefersReducedMotion: () => boolean;

package/dist/src/hooks/usePrefersReducedMotion/useReducedMotion.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Motion's reduced-motion hook. `true` or `false` after hydration, `null` during SSR.
+ * Prefer {@link usePrefersReducedMotion} when you want a boolean object that starts `false`.
+ */
+export { useReducedMotion } from 'motion/react';

package/dist/{stripInlineMarkdown-BhYLEiXu.js → stripInlineMarkdown-B6lAJb4-.js}

@@ -1,4 +1,4 @@
-import { I as INLINE_MARKDOWN_REGEX } from './FieldLabel-ThEmUiAq.js';
+import { I as INLINE_MARKDOWN_REGEX } from './FieldLabel-DYcUS3A4.js';
 
 const stripInlineMarkdown = (str) => {
   const parts = [];
@@ -22,4 +22,4 @@ const stripInlineMarkdown = (str) => {
 };
 
 export { stripInlineMarkdown as s };
-//# sourceMappingURL=stripInlineMarkdown-BhYLEiXu.js.map
+//# sourceMappingURL=stripInlineMarkdown-B6lAJb4-.js.map

package/dist/{stripInlineMarkdown-BhYLEiXu.js.map → stripInlineMarkdown-B6lAJb4-.js.map}

@@ -1 +1 @@
-{"version":3,"file":"stripInlineMarkdown-BhYLEiXu.js","sources":["../src/internal/functions/stripInlineMarkdown.ts"],"sourcesContent":["import { INLINE_MARKDOWN_REGEX } from \"../utils/inlineMarkdownRegex\";\n\n/**\n * Drops inline markdown markers and returns the inner text (for `aria-label`).\n * Shared global regex: reset `lastIndex` per call and save it around nested\n * strips. Code spans are not reparsed.\n */\nexport const stripInlineMarkdown = (str: string): string => {\n  const parts: string[] = [];\n  let lastIndex = 0;\n\n  INLINE_MARKDOWN_REGEX.lastIndex = 0;\n  let match: RegExpExecArray | null;\n\n  while ((match = INLINE_MARKDOWN_REGEX.exec(str)) !== null) {\n    if (match.index > lastIndex) {\n      parts.push(str.substring(lastIndex, match.index));\n    }\n\n    const savedIndex = INLINE_MARKDOWN_REGEX.lastIndex;\n    const inner =\n      match[1] ?? match[2] ?? match[3] ?? match[4] ?? match[5] ?? \"\";\n\n    parts.push(match[5] ? inner : stripInlineMarkdown(inner));\n\n    INLINE_MARKDOWN_REGEX.lastIndex = savedIndex;\n    lastIndex = savedIndex;\n  }\n\n  if (lastIndex < str.length) {\n    parts.push(str.substring(lastIndex));\n  }\n\n  return parts.join(\"\");\n};\n"],"names":[],"mappings":";;AAOO,MAAM,mBAAA,GAAsB,CAAC,GAAA,KAAwB;AAC1D,EAAA,MAAM,QAAkB,EAAC;AACzB,EAAA,IAAI,SAAA,GAAY,CAAA;AAEhB,EAAA,qBAAA,CAAsB,SAAA,GAAY,CAAA;AAClC,EAAA,IAAI,KAAA;AAEJ,EAAA,OAAA,CAAQ,KAAA,GAAQ,qBAAA,CAAsB,IAAA,CAAK,GAAG,OAAO,IAAA,EAAM;AACzD,IAAA,IAAI,KAAA,CAAM,QAAQ,SAAA,EAAW;AAC3B,MAAA,KAAA,CAAM,KAAK,GAAA,CAAI,SAAA,CAAU,SAAA,EAAW,KAAA,CAAM,KAAK,CAAC,CAAA;AAAA,IAClD;AAEA,IAAA,MAAM,aAAa,qBAAA,CAAsB,SAAA;AACzC,IAAA,MAAM,KAAA,GACJ,KAAA,CAAM,CAAC,CAAA,IAAK,MAAM,CAAC,CAAA,IAAK,KAAA,CAAM,CAAC,KAAK,KAAA,CAAM,CAAC,CAAA,IAAK,KAAA,CAAM,CAAC,CAAA,IAAK,EAAA;AAE9D,IAAA,KAAA,CAAM,KAAK,KAAA,CAAM,CAAC,IAAI,KAAA,GAAQ,mBAAA,CAAoB,KAAK,CAAC,CAAA;AAExD,IAAA,qBAAA,CAAsB,SAAA,GAAY,UAAA;AAClC,IAAA,SAAA,GAAY,UAAA;AAAA,EACd;AAEA,EAAA,IAAI,SAAA,GAAY,IAAI,MAAA,EAAQ;AAC1B,IAAA,KAAA,CAAM,IAAA,CAAK,GAAA,CAAI,SAAA,CAAU,SAAS,CAAC,CAAA;AAAA,EACrC;AAEA,EAAA,OAAO,KAAA,CAAM,KAAK,EAAE,CAAA;AACtB;;;;"}
+{"version":3,"file":"stripInlineMarkdown-B6lAJb4-.js","sources":["../src/internal/functions/stripInlineMarkdown.ts"],"sourcesContent":["import { INLINE_MARKDOWN_REGEX } from \"../utils/inlineMarkdownRegex\";\n\n/**\n * Drops inline markdown markers and returns the inner text (for `aria-label`).\n * Shared global regex: reset `lastIndex` per call and save it around nested\n * strips. Code spans are not reparsed.\n */\nexport const stripInlineMarkdown = (str: string): string => {\n  const parts: string[] = [];\n  let lastIndex = 0;\n\n  INLINE_MARKDOWN_REGEX.lastIndex = 0;\n  let match: RegExpExecArray | null;\n\n  while ((match = INLINE_MARKDOWN_REGEX.exec(str)) !== null) {\n    if (match.index > lastIndex) {\n      parts.push(str.substring(lastIndex, match.index));\n    }\n\n    const savedIndex = INLINE_MARKDOWN_REGEX.lastIndex;\n    const inner =\n      match[1] ?? match[2] ?? match[3] ?? match[4] ?? match[5] ?? \"\";\n\n    parts.push(match[5] ? inner : stripInlineMarkdown(inner));\n\n    INLINE_MARKDOWN_REGEX.lastIndex = savedIndex;\n    lastIndex = savedIndex;\n  }\n\n  if (lastIndex < str.length) {\n    parts.push(str.substring(lastIndex));\n  }\n\n  return parts.join(\"\");\n};\n"],"names":[],"mappings":";;AAOO,MAAM,mBAAA,GAAsB,CAAC,GAAA,KAAwB;AAC1D,EAAA,MAAM,QAAkB,EAAC;AACzB,EAAA,IAAI,SAAA,GAAY,CAAA;AAEhB,EAAA,qBAAA,CAAsB,SAAA,GAAY,CAAA;AAClC,EAAA,IAAI,KAAA;AAEJ,EAAA,OAAA,CAAQ,KAAA,GAAQ,qBAAA,CAAsB,IAAA,CAAK,GAAG,OAAO,IAAA,EAAM;AACzD,IAAA,IAAI,KAAA,CAAM,QAAQ,SAAA,EAAW;AAC3B,MAAA,KAAA,CAAM,KAAK,GAAA,CAAI,SAAA,CAAU,SAAA,EAAW,KAAA,CAAM,KAAK,CAAC,CAAA;AAAA,IAClD;AAEA,IAAA,MAAM,aAAa,qBAAA,CAAsB,SAAA;AACzC,IAAA,MAAM,KAAA,GACJ,KAAA,CAAM,CAAC,CAAA,IAAK,MAAM,CAAC,CAAA,IAAK,KAAA,CAAM,CAAC,KAAK,KAAA,CAAM,CAAC,CAAA,IAAK,KAAA,CAAM,CAAC,CAAA,IAAK,EAAA;AAE9D,IAAA,KAAA,CAAM,KAAK,KAAA,CAAM,CAAC,IAAI,KAAA,GAAQ,mBAAA,CAAoB,KAAK,CAAC,CAAA;AAExD,IAAA,qBAAA,CAAsB,SAAA,GAAY,UAAA;AAClC,IAAA,SAAA,GAAY,UAAA;AAAA,EACd;AAEA,EAAA,IAAI,SAAA,GAAY,IAAI,MAAA,EAAQ;AAC1B,IAAA,KAAA,CAAM,IAAA,CAAK,GAAA,CAAI,SAAA,CAAU,SAAS,CAAC,CAAA;AAAA,EACrC;AAEA,EAAA,OAAO,KAAA,CAAM,KAAK,EAAE,CAAA;AACtB;;;;"}