@acronis-platform/ui-react 0.55.0 → 0.56.1

package/dist/react.js.map

@@ -1 +1 @@
-{"version":3,"file":"react.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"react.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/src/components/ui/app-shell-chat/app-shell-chat.d.ts

@@ -0,0 +1,147 @@
+import * as React from 'react';
+export interface AppShellChatInitialLayout {
+    /** Initial `defaultExpanded` for SidebarPrimary. */
+    primaryExpanded: boolean;
+    /** Initial `defaultExpanded` for SidebarSecondary (when the screen has one). */
+    secondaryExpanded: boolean;
+}
+/**
+ * Pure breakpoint → layout mapping, exported for direct unit testing (the
+ * same convention `getResizeMaxWidth` above uses). `viewportWidth` of
+ * `undefined` (no `window`, e.g. SSR) falls back to `WIDE_SIDEBAR_LAYOUT` —
+ * the same value this component unconditionally hardcoded before this
+ * feature existed. Below `BREAKPOINT_3XL` the output is always
+ * `NARROW_SIDEBAR_LAYOUT` (primary closed), all the way down — the sidebars
+ * have no tier cut at `BREAKPOINT_XL` the way Chat's own width does; there is
+ * no separate floor tier either.
+ */
+export declare function getAppShellChatInitialLayout(viewportWidth: number | undefined): AppShellChatInitialLayout;
+/**
+ * Reads the breakpoint-derived initial sidebar layout ONCE, at first render
+ * — see the rationale above. Consumers wire the two fields into
+ * `SidebarPrimary`/`SidebarSecondary`'s existing `defaultExpanded` prop.
+ */
+export declare function useAppShellChatInitialLayout(): AppShellChatInitialLayout;
+/** Pure viewport → width mapping, exported for direct unit testing. */
+export declare function getLiveChatDefaultWidth(viewportWidth: number | undefined): number;
+export type AppShellChatProps = React.ComponentPropsWithoutRef<'div'>;
+declare const AppShellChat: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AppShellChatSidebar: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const AppShellChatContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AppShellChatContentHeader: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AppShellChatContentBody: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export interface AppShellChatChatContextValue {
+    /** Derived from `width <= minWidth` — true at the resize floor, where the header shows the icon instead of the label. */
+    compact: boolean;
+    width: number;
+    setWidth: (width: number) => void;
+    /**
+     * Clears any drag/keyboard override and restores the LIVE, breakpoint-driven
+     * width (see `getLiveChatDefaultWidth` above) — the double-click/Home
+     * target. NOT the same as `setWidth(someFixedNumber)`: that would just
+     * swap one frozen override for another and permanently disable live
+     * viewport tracking, which is the whole point of "reset".
+     */
+    resetWidth: () => void;
+    minWidth: number;
+    /** Fallback ceiling — see `CHAT_MAX_WIDTH_FALLBACK`. The resize handle prefers a live DOM measurement. */
+    maxWidth: number;
+    resizeAriaLabel: string;
+    resizeTooltip: React.ReactNode;
+}
+declare const AppShellChatChatContext: React.Context<AppShellChatChatContextValue | null>;
+/**
+ * The true resize ceiling: the row's total width minus everything in it
+ * EXCEPT Content (which can always shrink to 0) and Chat itself. This lets
+ * Chat reach full width — Content shrinking to 0 — instead of being capped by
+ * a fixed constant that strands Content with a bogus minimum once both
+ * sidebars are collapsed and the row has room to give. Exported for direct
+ * testing; `handleResizePointerDown` / `handleResizeKeyDown` are the real
+ * callers.
+ */
+export declare function getResizeMaxWidth(chatEl: HTMLElement, fallback: number): number;
+/** The subset of context `handleResizePointerDown` needs to drag-resize. */
+export type ResizePointerDownContext = Pick<AppShellChatChatContextValue, 'minWidth' | 'maxWidth' | 'setWidth'>;
+/**
+ * Pointerdown handler for the Chat resize edge: captures the pointer,
+ * disables the chat's width transition for the duration of the drag, and
+ * clamps width between `ctx.minWidth` and the dynamically-measured ceiling
+ * (`getResizeMaxWidth`) — NOT `ctx.maxWidth`, which is only the fallback used
+ * when that measurement is unavailable. Chat's END edge is pinned against the
+ * container's end, so dragging the pointer toward the row's start grows the
+ * chat — the mirror image of `SidebarSecondaryResizeEdge` (whose START edge is
+ * pinned). Exported for direct testing; `AppShellChatResizeEdge` is the real
+ * caller (it supplies `onDragStart`/`onDragEnd` to drive its own `dragging`
+ * state, e.g. to suppress the tooltip while dragging).
+ *
+ * `ctxRef` is a ref (not a plain snapshot): the drag's `pointermove`/`pointerup`
+ * listeners live on `window` for the whole gesture, and `ctx.setWidth`'s
+ * identity can change mid-drag from a re-render that has nothing to do with
+ * the drag itself (e.g. a consumer's `onWidthChange` prop is a fresh inline
+ * function every render, which changes `setWidth`'s `useCallback` identity).
+ * Reading `ctxRef.current.setWidth` on every move — instead of destructuring
+ * `setWidth` once up front — means the listeners always call whatever
+ * `setWidth` is current, the same defensive pattern
+ * `SidebarSecondaryResizeEdge` uses via its own `ctxRef`. `minWidth`/`maxWidth`
+ * are still snapshotted once at drag-start (matching the frozen `chatRect`
+ * they're paired with) since they're geometry, not a callback identity.
+ *
+ * Both `pointerup` and `pointercancel` end the drag (a cancelled gesture — a
+ * touch-scroll takeover, palm rejection, losing focus mid-drag — never fires
+ * `pointerup`, so relying on that alone leaks the listeners and leaves
+ * `dragging` stuck `true` forever). `ev.pointerId` is checked against the
+ * pointer that started the drag so a second, unrelated pointer (multi-touch on
+ * the 17px handle) can't feed this drag's math or end it early.
+ */
+export declare function handleResizePointerDown(e: React.PointerEvent<HTMLDivElement>, ctxRef: {
+    current: ResizePointerDownContext;
+}, { onDragStart, onDragEnd }?: {
+    onDragStart?: () => void;
+    onDragEnd?: () => void;
+}): void;
+/** The subset of context `handleResizeKeyDown` needs to resize via keyboard. */
+export type ResizeKeyDownContext = Pick<AppShellChatChatContextValue, 'minWidth' | 'maxWidth' | 'width' | 'setWidth' | 'resetWidth'>;
+/**
+ * Keydown handler for the Chat resize edge: ArrowLeft/ArrowRight resize by
+ * 16px, clamped to `[ctx.minWidth, the dynamically-measured ceiling]` (see
+ * `getResizeMaxWidth`) via the SAME `Math.min(Math.max(next, minWidth),
+ * maxWidth)` order the pointer-drag handler uses. That order matters when the
+ * row is narrow enough that the measured ceiling drops below `minWidth` (e.g.
+ * both sidebars expanded on a small viewport): clamping the floor first and
+ * the ceiling second means the ceiling always wins the degenerate case, so
+ * grow/shrink can't fight each other into a value outside the valid range.
+ * Growing Chat's width moves the boundary "toward the row's start", so the
+ * grow key is the OPPOSITE of `SidebarSecondaryResizeEdge`'s: ArrowLeft in
+ * LTR, ArrowRight in RTL.
+ *
+ * Home delegates to `ctx.resetWidth()` rather than computing a clamped
+ * number itself — `resetWidth` restores the LIVE breakpoint-driven width
+ * (see `AppShellChatChatContextValue.resetWidth`), which is always already
+ * in range, so no clamp is needed here. Exported for direct testing;
+ * `AppShellChatResizeEdge` is the real caller.
+ */
+export declare function handleResizeKeyDown(e: React.KeyboardEvent<HTMLDivElement>, ctx: ResizeKeyDownContext, dir: 'ltr' | 'rtl'): void;
+export declare function AppShellChatResizeEdge(): import("react/jsx-runtime").JSX.Element;
+export declare namespace AppShellChatResizeEdge {
+    var displayName: string;
+}
+export interface AppShellChatChatProps extends React.ComponentPropsWithoutRef<'aside'> {
+    /** Controlled width in px. */
+    width?: number;
+    /** Fires when the width changes due to a drag/keyboard interaction. */
+    onWidthChange?: (width: number) => void;
+    /** Accessible label for the resize edge (`role="separator"`). Defaults to `'Resize chat'`. */
+    resizeAriaLabel?: string;
+    /** Tooltip content shown on the resize edge. Pass `null` to hide the tooltip entirely. */
+    resizeTooltip?: React.ReactNode;
+}
+declare const AppShellChatChat: React.ForwardRefExoticComponent<AppShellChatChatProps & React.RefAttributes<HTMLElement>>;
+export interface AppShellChatChatHeaderProps extends React.ComponentPropsWithoutRef<'div'> {
+    /** Header title (or pass as children). */
+    label?: React.ReactNode;
+    /** Trailing header actions. Hidden while compact (icon-only rail). */
+    actions?: React.ReactNode;
+}
+declare const AppShellChatChatHeader: React.ForwardRefExoticComponent<AppShellChatChatHeaderProps & React.RefAttributes<HTMLDivElement>>;
+declare const AppShellChatChatBody: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { AppShellChat, AppShellChatSidebar, AppShellChatContent, AppShellChatContentHeader, AppShellChatContentBody, AppShellChatChat, AppShellChatChatHeader, AppShellChatChatBody, AppShellChatChatContext, };

package/dist/src/components/ui/app-shell-chat/index.d.ts

@@ -0,0 +1 @@
+export { AppShellChat, AppShellChatSidebar, AppShellChatContent, AppShellChatContentHeader, AppShellChatContentBody, AppShellChatChat, AppShellChatChatHeader, AppShellChatChatBody, useAppShellChatInitialLayout, getAppShellChatInitialLayout, type AppShellChatProps, type AppShellChatChatProps, type AppShellChatChatHeaderProps, type AppShellChatInitialLayout, } from './app-shell-chat';

package/dist/src/components/ui/button/button.d.ts

@@ -2,7 +2,7 @@ import { useRender } from '@base-ui/react/use-render';
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const buttonVariants: (props?: ({
-    variant?: "destructive" | "ai" | "default" | "secondary" | "ghost" | "inverted" | null | undefined;
+    variant?: "destructive" | "ai" | "default" | "secondary" | "ghost" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
     /**

package/dist/src/components/ui/calendar/calendar.d.ts

@@ -0,0 +1,6 @@
+import { DayButton, DayPicker } from 'react-day-picker';
+import * as React from 'react';
+export type CalendarProps = React.ComponentProps<typeof DayPicker>;
+declare function Calendar({ className, classNames, showOutsideDays, captionLayout, weekStartsOn, formatters, components, ...props }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+declare function CalendarDayButton({ className, day, modifiers, ...props }: React.ComponentProps<typeof DayButton>): import("react/jsx-runtime").JSX.Element;
+export { Calendar, CalendarDayButton };

package/dist/src/components/ui/calendar/calendar.docs.d.ts

@@ -0,0 +1,21 @@
+/** Props for `Calendar` — a day grid built on `react-day-picker`'s `DayPicker`. */
+export interface CalendarProps {
+    /** Selection mode. Defaults to `single`. */
+    mode?: 'single' | 'multiple' | 'range';
+    /** How many months to render side by side. Defaults to `1`. */
+    numberOfMonths?: number;
+    /** Show days from the previous/next month to fill the grid. Defaults to `true`. */
+    showOutsideDays?: boolean;
+    /** How the month/year caption is rendered. Defaults to `label`. */
+    captionLayout?: 'label' | 'dropdown' | 'dropdown-months' | 'dropdown-years';
+    /** The controlled selection; shape depends on `mode` (`Date`, `Date[]`, or a `{ from, to }` range). */
+    selected?: unknown;
+    /** Called when the selection changes. */
+    onSelect?: (selected: unknown) => void;
+    /** Matcher (or array of matchers) for days that cannot be selected. */
+    disabled?: unknown;
+    /** The month rendered first (uncontrolled). */
+    defaultMonth?: Date;
+    /** Extra classes merged onto the calendar root. */
+    className?: string;
+}

package/dist/src/components/ui/calendar/index.d.ts

@@ -0,0 +1 @@
+export { Calendar, CalendarDayButton, type CalendarProps } from './calendar';

package/dist/src/components/ui/data-table/data-table-expand-trigger.d.ts

@@ -0,0 +1,10 @@
+import { Row } from '@tanstack/react-table';
+import * as React from 'react';
+interface DataTableExpandTriggerProps<TData> extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    /** The row this trigger toggles. */
+    row: Row<TData>;
+}
+export declare const DataTableExpandTrigger: <TData>(props: DataTableExpandTriggerProps<TData> & {
+    ref?: React.Ref<HTMLButtonElement>;
+}) => React.ReactElement | null;
+export {};

package/dist/src/components/ui/data-table/data-table-toolbar.d.ts

@@ -1,9 +1,27 @@
+import { ReactNode } from 'react';
 import { Table } from '@tanstack/react-table';
 interface DataTableToolbarProps<TData> {
     table: Table<TData>;
+    /**
+     * Rendered as the leading element of the toolbar row, before the search
+     * box — e.g. a tenant/scope `Select` (matches the Figma "FilterSearch"
+     * anatomy, which places a scope switcher ahead of search).
+     */
+    leading?: ReactNode;
     /** Column id to wire the search box to (client-side text filter). */
     searchKey?: string;
     searchPlaceholder?: string;
+    /**
+     * Filter field children rendered inside the `FilterSearchFilters` popover.
+     * Wire each field to a column via `useFilterSearchFilters()` keyed by column
+     * id. When provided, the toolbar renders the filter popover + an applied-filter
+     * chip row below it.
+     */
+    children?: ReactNode;
+    /** Label for the filters trigger button. */
+    filtersLabel?: ReactNode;
+    /** Format an applied-filter chip's label (defaults to `"<id>: <value>"`). */
+    getFilterChipLabel?: (key: string, value: unknown) => ReactNode;
 }
-export declare function DataTableToolbar<TData>({ table, searchKey, searchPlaceholder, }: DataTableToolbarProps<TData>): import("react/jsx-runtime").JSX.Element;
+export declare function DataTableToolbar<TData>({ table, leading, searchKey, searchPlaceholder, children, filtersLabel, getFilterChipLabel, }: DataTableToolbarProps<TData>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/components/ui/data-table/data-table.d.ts

@@ -1,5 +1,27 @@
 import { ReactNode } from 'react';
-import { ColumnDef, Row } from '@tanstack/react-table';
+import { ColumnDef, ColumnSizingState, OnChangeFn, Row, RowData, VisibilityState } from '@tanstack/react-table';
+declare module '@tanstack/react-table' {
+    interface ColumnMeta<TData extends RowData, TValue> {
+        /** Pin the column to a table edge (sticky while the grid scrolls horizontally). */
+        pin?: 'left' | 'right';
+        /**
+         * Let the column's header + cells wrap onto multiple lines (drops the fixed
+         * row height); mirrors the `Table` primitives' `wrap` prop on TableHead/TableCell.
+         */
+        wrap?: boolean;
+    }
+}
+/**
+ * Computes the next column width for an Arrow-key resize step (Shift = larger
+ * step), clamped to `[min, max]` regardless of which bound `currentSize`
+ * started outside of. Returns `undefined` for any other key, so the caller
+ * knows not to `preventDefault()`/resize.
+ */
+export declare function getResizeKeyboardStep(key: string, currentSize: number, { shiftKey, min, max }: {
+    shiftKey: boolean;
+    min: number;
+    max: number;
+}): number | undefined;
 export interface DataTableProps<TData, TValue> {
     columns: ColumnDef<TData, TValue>[];
     data: TData[];
@@ -20,5 +42,21 @@ export interface DataTableProps<TData, TValue> {
     skeleton?: boolean;
     /** Number of skeleton rows to render when `skeleton` is set. */
     skeletonRows?: number;
+    /**
+     * Opt in to interactive column resizing. Renders a drag handle at the trailing
+     * edge of each resizable header cell (TanStack's native `columnResizing`).
+     */
+    enableColumnResizing?: boolean;
+    /** Passthrough for the `columnSizing` state so a consumer can persist widths. */
+    onColumnSizingChange?: OnChangeFn<ColumnSizingState>;
+    /**
+     * Controlled column-visibility state — pass this (with
+     * `onColumnVisibilityChange`) to share one visibility state with an
+     * external `useReactTable` instance (e.g. a composed toolbar). Uncontrolled
+     * (internal state) when omitted.
+     */
+    columnVisibility?: VisibilityState;
+    /** Passthrough for the `columnVisibility` state; pairs with `columnVisibility`. */
+    onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
 }
-export declare function DataTable<TData, TValue>({ columns, data, getRowCanExpand, renderExpandedRow, striped, bordered, highlightCurrentRow, skeleton, skeletonRows, }: DataTableProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export declare function DataTable<TData, TValue>({ columns, data, getRowCanExpand, renderExpandedRow, striped, bordered, highlightCurrentRow, skeleton, skeletonRows, enableColumnResizing, onColumnSizingChange, columnVisibility: controlledColumnVisibility, onColumnVisibilityChange, }: DataTableProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/ui/data-table/index.d.ts

@@ -1,5 +1,6 @@
 export { DataTable, type DataTableProps } from './data-table';
 export { DataTableColumnHeader } from './data-table-column-header';
+export { DataTableExpandTrigger } from './data-table-expand-trigger';
 export { DataTablePagination } from './data-table-pagination';
 export { DataTableToolbar } from './data-table-toolbar';
 export { DataTableViewOptions } from './data-table-view-options';

package/dist/src/components/ui/date-range-picker/__tests__/date-range-picker-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/ui/date-range-picker/date-range-picker-utils.d.ts

@@ -0,0 +1,36 @@
+/** A start/end date range. Both ends are optional (a partial range while editing). */
+export interface DateRange {
+    from?: Date;
+    to?: Date;
+}
+/** The date display / parse pattern used by the trigger and the editable fields. */
+export declare const DISPLAY_FORMAT = "MMM d, yyyy";
+/**
+ * Format a date with {@link DISPLAY_FORMAT}, returning `''` for a missing or
+ * invalid `Date`. `date-fns`' `format` throws a `RangeError` on an invalid
+ * `Date` (e.g. `new Date('garbage')`), so the `isValid` guard is load-bearing —
+ * a truthy-but-invalid `Date` must not reach `format`.
+ */
+export declare function formatDate(date: Date | undefined): string;
+/**
+ * Parse a {@link DISPLAY_FORMAT} string into a `Date`, or `undefined` when the
+ * text is empty, partial (mid-type), or not a real calendar date
+ * (e.g. `"Feb 30, 2026"`). The result is normalized to the start of the day so
+ * it round-trips with {@link formatDate} — `date-fns`' `parse` fills the unspecified
+ * time-of-day from its reference date, which would otherwise leave a "now" time
+ * on the value and break equality with the midnight dates the calendar emits.
+ *
+ * NOTE: the pattern is locale-fixed (US-style `MMM d, yyyy`), matching the
+ * `InputDatePicker` trigger. Locale-aware parsing is not yet supported — a
+ * known limitation to revisit once the design tier lands.
+ */
+export declare function parseDate(text: string): Date | undefined;
+/** Structural equality of two ranges by their endpoints' timestamps. */
+export declare function rangesEqual(a: DateRange, b: DateRange): boolean;
+/**
+ * Return a range whose `from` is never after its `to`. When both ends are set
+ * and inverted (e.g. the user typed an end date earlier than the start), the two
+ * are swapped; a partial range (one end unset) is returned unchanged. Used to
+ * keep the calendar highlight and the committed value chronologically ordered.
+ */
+export declare function normalizeRange(range: DateRange): DateRange;

package/dist/src/components/ui/date-range-picker/date-range-picker.d.ts

@@ -0,0 +1,27 @@
+import { DateRange } from './date-range-picker-utils';
+import * as React from 'react';
+export type { DateRange };
+export interface DateRangePickerProps {
+    /** The applied range (controlled). Omit for uncontrolled use with `defaultValue`. */
+    value?: DateRange;
+    /** The initial applied range (uncontrolled) and the target of "Reset to default". */
+    defaultValue?: DateRange;
+    /** Called with the committed range when Apply is pressed. */
+    onValueChange?: (range: DateRange) => void;
+    /** Field label for the trigger. */
+    label?: React.ReactNode;
+    /** Helper text below the trigger. */
+    description?: React.ReactNode;
+    /** Error message below the trigger (switches the trigger to its error treatment). */
+    error?: React.ReactNode;
+    /** Hint shown in the trigger when no range is selected. */
+    placeholder?: React.ReactNode;
+    /** Disables the trigger and prevents opening the popover. */
+    disabled?: boolean;
+    /** Marks the trigger required. */
+    required?: boolean;
+    /** Extra classes merged onto the trigger. */
+    className?: string;
+}
+declare const DateRangePicker: React.ForwardRefExoticComponent<DateRangePickerProps & React.RefAttributes<HTMLButtonElement>>;
+export { DateRangePicker };

package/dist/src/components/ui/date-range-picker/index.d.ts

@@ -0,0 +1 @@
+export { DateRangePicker, type DateRangePickerProps, type DateRange, } from './date-range-picker';

package/dist/src/components/ui/dropdown-menu/dropdown-menu.d.ts

@@ -2,10 +2,9 @@ import { Menu as MenuPrimitive } from '@base-ui/react/menu';
 import * as React from 'react';
 declare const DropdownMenu: <Payload>(props: MenuPrimitive.Root.Props<Payload>) => import("react/jsx-runtime").JSX.Element;
 declare const DropdownMenuTrigger: MenuPrimitive.Trigger;
-declare const DropdownMenuGroup: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').ContextMenuGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const DropdownMenuPortal: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').ContextMenuPortalProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const DropdownMenuSub: typeof MenuPrimitive.SubmenuRoot;
-declare const DropdownMenuRadioGroup: React.NamedExoticComponent<Omit<import('@base-ui/react').ContextMenuRadioGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export interface DropdownMenuContentProps extends React.ComponentPropsWithoutRef<typeof MenuPrimitive.Popup> {
     side?: MenuPrimitive.Positioner.Props['side'];
     align?: MenuPrimitive.Positioner.Props['align'];
@@ -26,14 +25,8 @@ declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<Omit<import
 declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuSubmenuTriggerProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & {
     inset?: boolean;
 } & React.RefAttributes<HTMLElement>>;
-declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuCheckboxItemProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
-declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuRadioItemProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
-declare const DropdownMenuLabel: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
-    inset?: boolean;
-} & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
 declare function DropdownMenuShortcut({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
 declare namespace DropdownMenuShortcut {
     var displayName: string;
 }
-export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuPortal, };

package/dist/src/components/ui/dropdown-menu/index.d.ts

@@ -1 +1 @@
-export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, type DropdownMenuContentProps, } from './dropdown-menu';
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuPortal, type DropdownMenuContentProps, } from './dropdown-menu';

package/dist/src/components/ui/filter-search/filter-search.d.ts

@@ -3,4 +3,50 @@ export type FilterSearchProps = React.ComponentPropsWithoutRef<'div'>;
 declare const FilterSearch: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export type FilterSearchActionsProps = React.ComponentPropsWithoutRef<'div'>;
 declare const FilterSearchActions: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-export { FilterSearch, FilterSearchActions };
+interface FilterSearchFiltersContextValue {
+    /** The current draft filters being edited inside the popover. */
+    filters: Record<string, unknown>;
+    /** Set a single draft filter value by key. */
+    setFilter: (key: string, value: unknown) => void;
+}
+/**
+ * Bind a filter field child (rendered inside `FilterSearchFilters`'s popover) to
+ * the component's draft filters. Returns the current draft map and a per-key
+ * setter. Field children are plain JSX (no render prop) and wire their own
+ * `onChange` to `setFilter`; Apply commits the draft, Cancel/dismiss reverts it.
+ */
+export declare function useFilterSearchFilters(): FilterSearchFiltersContextValue;
+export interface FilterSearchFiltersProps {
+    /** The applied filter values, keyed by an arbitrary consumer-chosen id. */
+    value: Record<string, unknown>;
+    /** Called with the committed filters when Apply is pressed. */
+    onValueChange: (next: Record<string, unknown>) => void;
+    /** Called with the newly applied filters when Apply is pressed (fires alongside `onValueChange`). */
+    onApply?: (filters: Record<string, unknown>) => void;
+    /** Label for the filter trigger button. */
+    label?: React.ReactNode;
+    /**
+     * Filter field children rendered inside the popover form. Plain children —
+     * wire each field to the draft via `useFilterSearchFilters`. Group fields with
+     * a `Separator` as a layout convention if desired.
+     */
+    children?: React.ReactNode;
+    /** Additional classes merged onto the trigger button. */
+    className?: string;
+}
+declare const FilterSearchFilters: React.ForwardRefExoticComponent<FilterSearchFiltersProps & React.RefAttributes<HTMLButtonElement>>;
+export interface FilterSearchAppliedFiltersProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
+    /** The currently applied filter values, keyed by an arbitrary consumer-chosen id. */
+    filters: Record<string, unknown>;
+    /** Called with the remaining filters when a chip is removed or "Reset filters" clears all. */
+    onValueChange: (next: Record<string, unknown>) => void;
+    /** Format an applied-filter chip's label. Defaults to `"<key>: <value>"`. */
+    getFilterChipLabel?: (key: string, value: unknown) => React.ReactNode;
+}
+/**
+ * Renders one removable chip per applied filter plus a "Reset filters" action
+ * that clears all filters immediately (no popover involved). Renders nothing
+ * when `filters` is empty.
+ */
+declare const FilterSearchAppliedFilters: React.ForwardRefExoticComponent<FilterSearchAppliedFiltersProps & React.RefAttributes<HTMLDivElement>>;
+export { FilterSearch, FilterSearchActions, FilterSearchFilters, FilterSearchAppliedFilters, };

package/dist/src/components/ui/filter-search/index.d.ts

@@ -1,2 +1,2 @@
-export { FilterSearch, FilterSearchActions, } from './filter-search';
-export type { FilterSearchProps, FilterSearchActionsProps } from './filter-search';
+export { FilterSearch, FilterSearchActions, FilterSearchFilters, FilterSearchAppliedFilters, useFilterSearchFilters, } from './filter-search';
+export type { FilterSearchProps, FilterSearchActionsProps, FilterSearchFiltersProps, FilterSearchAppliedFiltersProps, } from './filter-search';

package/dist/src/components/ui/grid/grid.d.ts

@@ -1,7 +1,7 @@
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const gridVariants: (props?: ({
-    cols?: 1 | 2 | 4 | 3 | 6 | 12 | null | undefined;
+    cols?: 1 | 2 | 6 | 3 | 4 | 12 | null | undefined;
     gap?: "none" | "sm" | "md" | "lg" | "xl" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface GridProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof gridVariants> {

package/dist/src/components/ui/input-select/index.d.ts

@@ -1 +1 @@
-export { InputSelect, InputSelectField, InputSelectLabel, InputSelectTrigger, InputSelectValue, InputSelectContent, InputSelectSearch, InputSelectGroup, InputSelectSection, InputSelectSectionLabel, InputSelectItem, InputSelectDescription, InputSelectError, InputSelectStatus, type InputSelectStatusProps, } from './input-select';
+export { InputSelect, InputSelectField, InputSelectLabel, InputSelectTrigger, InputSelectValue, InputSelectContent, InputSelectSearch, InputSelectGroup, InputSelectSection, InputSelectSectionLabel, InputSelectItem, InputSelectExpander, InputSelectDescription, InputSelectError, InputSelectStatus, useInputSelectFilter, type InputSelectItemProps, type InputSelectExpanderProps, type InputSelectStatusProps, } from './input-select';

package/dist/src/components/ui/input-select/input-select.d.ts

@@ -1,5 +1,17 @@
 import { Select as SelectPrimitive } from '@base-ui/react/select';
 import * as React from 'react';
+interface InputSelectFilterContextValue {
+    /** Current in-dropdown search query. */
+    query: string;
+    /** Update the search query. */
+    setQuery: (query: string) => void;
+}
+/**
+ * Read the live in-dropdown search query (and its setter) from the nearest
+ * `InputSelect`. Flat item lists filter themselves; use this for hierarchical
+ * (tree) dropdowns that need to compute their own visibility.
+ */
+declare function useInputSelectFilter(): InputSelectFilterContextValue;
 declare function InputSelect<Value, Multiple extends boolean | undefined = false>(props: SelectPrimitive.Root.Props<Value, Multiple>): import("react/jsx-runtime").JSX.Element;
 declare namespace InputSelect {
     var displayName: string;
@@ -25,14 +37,52 @@ declare const InputSelectContent: React.ForwardRefExoticComponent<Omit<Omit<impo
     portalContainer?: SelectPrimitive.Portal.Props["container"];
 } & React.RefAttributes<HTMLDivElement>>;
 /**
- * Presentational in-dropdown search row (magnifier + input). The consumer wires
- * `value`/`onChange` to filter the items it renders.
+ * In-dropdown search row (magnifier + input). By default it drives the
+ * `InputSelect` filter context — flat `InputSelectItem`s filter themselves, and
+ * tree dropdowns read the query via `useInputSelectFilter`. Pass `value`/`onChange`
+ * to control the query externally.
  */
 declare const InputSelectSearch: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
 /** A section (group) of items with an optional header. Divided by a top border. */
 declare const InputSelectSection: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').SelectGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const InputSelectSectionLabel: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').SelectGroupLabelProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const InputSelectItem: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').SelectItemProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+export interface InputSelectItemProps extends React.ComponentPropsWithoutRef<typeof SelectPrimitive.Item> {
+    /** Optional leading icon rendered before the label text. Colored by `--ui-input-select-dropdown-item-global-icon-tenant`. */
+    icon?: React.ReactNode;
+    /** 1-based nesting level (0 / omitted = no indent). Levels 1–3 reserve 16 / 40 / 64 px. */
+    indent?: number;
+    /**
+     * Text used to match the in-dropdown search query. Defaults to the string
+     * `children`. When a query is active and this text doesn't match, the row hides
+     * itself — unless `hidden` is passed explicitly (tree dropdowns compute their own
+     * visibility). Rows stay mounted while hidden to keep Base UI's selection index
+     * stable.
+     */
+    textValue?: string;
+}
+declare const InputSelectItem: React.ForwardRefExoticComponent<InputSelectItemProps & React.RefAttributes<HTMLElement>>;
+export interface InputSelectExpanderProps extends React.ComponentPropsWithoutRef<'button'> {
+    /** Whether the group is currently expanded. */
+    expanded: boolean;
+    /** Called when the user clicks the row to toggle expand/collapse. */
+    onToggle: () => void;
+    /** Optional leading icon rendered after the chevron. */
+    icon?: React.ReactNode;
+    /** 1-based nesting level (0 / omitted = level 1). Levels 1–3 reserve 16 / 40 / 64 px; the chevron sits right-aligned inside. */
+    indent?: number;
+}
+/**
+ * A non-selectable row that acts as an expand/collapse toggle for a tree group.
+ * Visually identical to `InputSelectItem` but is **not** a `SelectPrimitive.Item`,
+ * so clicking it won't set the select value.
+ *
+ * When collapsing a group, keep its child `InputSelectItem`s mounted and toggle
+ * their `hidden` prop rather than unmounting them: Base UI's Select tracks the
+ * selection by list index, so removing the selected row from the DOM makes a
+ * sibling inherit its index and render a phantom check. `hidden` rows keep the
+ * indices stable and are skipped by keyboard navigation.
+ */
+declare const InputSelectExpander: React.ForwardRefExoticComponent<InputSelectExpanderProps & React.RefAttributes<HTMLButtonElement>>;
 declare const InputSelectDescription: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
 declare const InputSelectError: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
 export interface InputSelectStatusProps extends React.ComponentPropsWithoutRef<'div'> {
@@ -43,4 +93,4 @@ export interface InputSelectStatusProps extends React.ComponentPropsWithoutRef<'
 }
 /** Loading / empty / error status row shown instead of items inside the dropdown. */
 declare const InputSelectStatus: React.ForwardRefExoticComponent<InputSelectStatusProps & React.RefAttributes<HTMLDivElement>>;
-export { InputSelect, InputSelectField, InputSelectLabel, InputSelectTrigger, InputSelectValue, InputSelectContent, InputSelectSearch, InputSelectGroup, InputSelectSection, InputSelectSectionLabel, InputSelectItem, InputSelectDescription, InputSelectError, InputSelectStatus, };
+export { InputSelect, InputSelectField, InputSelectLabel, InputSelectTrigger, InputSelectValue, InputSelectContent, InputSelectSearch, InputSelectGroup, InputSelectSection, InputSelectSectionLabel, InputSelectItem, InputSelectExpander, InputSelectDescription, InputSelectError, InputSelectStatus, useInputSelectFilter, };

package/dist/src/components/ui/sidebar-primary/sidebar-primary.d.ts

@@ -48,11 +48,9 @@ declare const SidebarPrimaryMenu: React.ForwardRefExoticComponent<Omit<React.Det
 declare const sidebarPrimaryMenuItemVariants: (props?: ({
     variant?: "selected" | "unselected" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-export interface SidebarPrimaryMenuItemProps extends Omit<React.ComponentPropsWithoutRef<'a'>, 'children'>, Omit<VariantProps<typeof sidebarPrimaryMenuItemVariants>, 'variant'> {
+interface SidebarPrimaryMenuItemBaseProps extends Omit<React.ComponentPropsWithoutRef<'a'>, 'children'>, Omit<VariantProps<typeof sidebarPrimaryMenuItemVariants>, 'variant'> {
     /** Marks the current route: sets the `selected` variant + `aria-current="page"`. */
     selected?: boolean;
-    /** Leading 16px icon (from `@acronis-platform/icons-react`). */
-    icon?: React.ReactNode;
     children?: React.ReactNode;
     /**
      * Trailing affordance — a `SidebarPrimaryMenuItemExtras` element. Rendered as
@@ -69,6 +67,14 @@ export interface SidebarPrimaryMenuItemProps extends Omit<React.ComponentPropsWi
      */
     render?: useRender.RenderProp;
 }
+export type SidebarPrimaryMenuItemProps = SidebarPrimaryMenuItemBaseProps & ({
+    /** Leading 16px icon (from `@acronis-platform/icons-react`). */
+    icon: Exclude<React.ReactNode, undefined>;
+    noIcon?: never;
+} | {
+    icon?: undefined; /** Explicit opt-out for the rare row with no icon. */
+    noIcon: true;
+});
 declare const SidebarPrimaryMenuItem: React.ForwardRefExoticComponent<SidebarPrimaryMenuItemProps & React.RefAttributes<HTMLAnchorElement>>;
 export interface SidebarPrimaryMenuItemExtrasProps extends React.ComponentPropsWithoutRef<'span'> {
     /** Which trailing affordance to render. */
@@ -85,7 +91,7 @@ export interface SidebarPrimaryMenuItemExtrasProps extends React.ComponentPropsW
 }
 declare const SidebarPrimaryMenuItemExtras: React.ForwardRefExoticComponent<SidebarPrimaryMenuItemExtrasProps & React.RefAttributes<HTMLSpanElement>>;
 export interface SidebarPrimaryCollapseTriggerProps extends Omit<React.ComponentPropsWithoutRef<'button'>, 'children'> {
-    /** Leading 16px icon (e.g. a panel-left glyph). */
+    /** Leading 16px icon (e.g. a panel-left glyph). Rotates 180° between expanded/collapsed. */
     icon?: React.ReactNode;
     children?: React.ReactNode;
     /**
@@ -94,6 +100,8 @@ export interface SidebarPrimaryCollapseTriggerProps extends Omit<React.Component
      * as `SidebarPrimaryMenuItem`'s `extras` prop.
      */
     extras?: React.ReactNode;
+    /** Tooltip text shown when the rail is collapsed. Defaults to `'Expand'`. */
+    expandTooltip?: React.ReactNode;
 }
 declare const SidebarPrimaryCollapseTrigger: React.ForwardRefExoticComponent<SidebarPrimaryCollapseTriggerProps & React.RefAttributes<HTMLButtonElement>>;
 export { SidebarPrimary, SidebarPrimaryHeader, SidebarPrimaryContent, SidebarPrimaryFooter, SidebarPrimarySection, SidebarPrimaryMenu, SidebarPrimaryMenuItem, SidebarPrimaryMenuItemExtras, SidebarPrimaryCollapseTrigger, useIsOverflowing, sidebarPrimaryMenuItemVariants, };

package/dist/src/components/ui/sidebar-secondary/sidebar-secondary.d.ts

@@ -103,10 +103,8 @@ export interface SidebarSecondaryMenuItemExtrasProps extends React.ComponentProp
 }
 declare const SidebarSecondaryMenuItemExtras: React.ForwardRefExoticComponent<SidebarSecondaryMenuItemExtrasProps & React.RefAttributes<HTMLSpanElement>>;
 export interface SidebarSecondaryCollapseTriggerProps extends Omit<React.ComponentPropsWithoutRef<'button'>, 'children'> {
-    /** Icon shown when the sidebar is expanded (collapse affordance). */
+    /** Leading 16px icon (e.g. a panel-left glyph). Rotates 180° between expanded/collapsed — same as `SidebarPrimaryCollapseTrigger`. */
     icon?: React.ReactNode;
-    /** Icon shown when the sidebar is collapsed (expand affordance). Falls back to `icon` when omitted. */
-    expandIcon?: React.ReactNode;
     /** Tooltip text shown when the sidebar is collapsed. Defaults to `'Expand'`. */
     expandTooltip?: React.ReactNode;
     /** Trailing extras (e.g. a keyboard shortcut hint), same slot as `SidebarSecondaryMenuItem`. */