@acronis-platform/ui-react 0.61.0 → 1.0.0

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/alert/alert.d.ts

@@ -1,14 +1,45 @@
 import { VariantProps } from 'class-variance-authority';
+import { ButtonIconProps } from '../button-icon';
 import * as React from 'react';
 declare const alertVariants: (props?: ({
-    variant?: "info" | "success" | "warning" | "critical" | "destructive" | "ai" | "neutral" | null | undefined;
+    variant?: "info" | "success" | "warning" | "critical" | "danger" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type AlertVariant = NonNullable<VariantProps<typeof alertVariants>['variant']>;
 export interface AlertProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof alertVariants> {
 }
+/**
+ * A status banner: neutral surface, a status-colored border, and a status line
+ * down the leading edge. Compose it from `AlertIcon`, `AlertContent`
+ * (`AlertText` + `AlertTitle` / `AlertDescription`, optionally `AlertActions`)
+ * and `AlertClose`.
+ */
 declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * The leading status icon. Renders the variant's own icon when given no
+ * `children`; pass children to substitute a different glyph.
+ */
 declare const AlertIcon: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
 declare const AlertContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * The title + description block. Its own vertical padding is what keeps the
+ * text aligned with the icon, so keep the title and description inside it
+ * rather than directly under `AlertContent`.
+ */
+declare const AlertText: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
 declare const AlertTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
-declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+/**
+ * Action buttons under the text. Place inside `AlertContent` (after
+ * `AlertText`), as the Figma does — the row wraps when it runs out of width.
+ */
 declare const AlertActions: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-export { Alert, AlertIcon, AlertContent, AlertTitle, AlertDescription, AlertActions, };
+export interface AlertCloseProps extends Omit<ButtonIconProps, 'children' | 'variant' | 'render' | 'aria-label'> {
+    /** Accessible name for the dismiss control. */
+    ariaLabel?: string;
+}
+/**
+ * The trailing dismiss control. Rendering it is what makes an alert
+ * dismissable — wire `onClick` to remove the alert. Name it with `ariaLabel`.
+ */
+declare const AlertClose: React.ForwardRefExoticComponent<AlertCloseProps & React.RefAttributes<HTMLButtonElement>>;
+export { Alert, AlertIcon, AlertContent, AlertText, AlertTitle, AlertDescription, AlertActions, AlertClose, alertVariants, };

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

@@ -1,2 +1,2 @@
-export { Alert, AlertIcon, AlertContent, AlertTitle, AlertDescription, AlertActions, } from './alert';
-export type { AlertProps } from './alert';
+export { Alert, AlertIcon, AlertContent, AlertText, AlertTitle, AlertDescription, AlertActions, AlertClose, alertVariants, } from './alert';
+export type { AlertProps, AlertCloseProps, AlertVariant } from './alert';

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" | "secondary" | "default" | "ghost" | null | undefined;
+    variant?: "ghost" | "secondary" | "default" | "destructive" | "ai" | 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/button-group/button-group.d.ts

@@ -0,0 +1,38 @@
+import { ToolbarButtonProps, ToolbarRootProps } from '@base-ui/react/toolbar';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const buttonGroupVariants: (props?: ({
+    variant?: "outlined" | "inlined" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const buttonGroupItemVariants: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export interface ButtonGroupProps extends Omit<ToolbarRootProps, 'className' | 'orientation'>, VariantProps<typeof buttonGroupVariants> {
+    className?: string;
+}
+/**
+ * A cluster of related icon-only actions sharing a single bordered box.
+ *
+ * Renders a `role="toolbar"` container: the group is one Tab stop and the
+ * arrow keys move between items. Give it an accessible name (`aria-label` or
+ * `aria-labelledby`) describing what the actions have in common.
+ */
+declare const ButtonGroup: React.ForwardRefExoticComponent<Omit<ButtonGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/** Mirrors the Figma `ButtonGroupItem` `order` variant. */
+export type ButtonGroupItemOrder = 'first' | 'middle' | 'last';
+export interface ButtonGroupItemProps extends Omit<ToolbarButtonProps, 'className'> {
+    className?: string;
+    /**
+     * Position within the group, mirroring the Figma `order` variant. Controls
+     * one thing: whether the trailing separator is drawn (`last` omits it).
+     *
+     * Leave it unset — position is derived from the DOM. Only pass it when each
+     * item is wrapped in another element, which defeats that derivation.
+     */
+    order?: ButtonGroupItemOrder;
+}
+/**
+ * A single action inside a `ButtonGroup`. The icon is passed as `children`;
+ * provide an `aria-label` (or `aria-labelledby`) so the control has an
+ * accessible name.
+ */
+declare const ButtonGroupItem: React.ForwardRefExoticComponent<Omit<ButtonGroupItemProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { ButtonGroup, ButtonGroupItem, buttonGroupVariants, buttonGroupItemVariants, };

package/dist/src/components/ui/button-group/index.d.ts

@@ -0,0 +1 @@
+export { ButtonGroup, ButtonGroupItem, buttonGroupVariants, buttonGroupItemVariants, type ButtonGroupProps, type ButtonGroupItemProps, type ButtonGroupItemOrder, } from './button-group';

package/dist/src/components/ui/button-icon/button-icon.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 buttonIconVariants: (props?: ({
-    variant?: "secondary" | "ghost" | null | undefined;
+    variant?: "ghost" | "secondary" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface ButtonIconProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonIconVariants> {
     /**

package/dist/src/components/ui/button-icon-menu/button-icon-menu.d.ts

@@ -0,0 +1,28 @@
+import { useRender } from '@base-ui/react/use-render';
+import * as React from 'react';
+export interface ButtonIconMenuProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    /**
+     * Whether the associated menu is open. Applies the open (`*-active`)
+     * treatment and reflects `aria-expanded`. Control this in sync with the menu
+     * you trigger.
+     */
+    open?: boolean;
+    /**
+     * Accessible name for the trigger. The button is icon-only, so it has no text
+     * to name it — pass a localized string here.
+     */
+    ariaLabel?: string;
+    /**
+     * Replace the rendered `<button>` with another element or component
+     * (Base UI composition). Accepts a React element or a render function —
+     * the component's props and class names are merged onto it.
+     */
+    render?: useRender.RenderProp;
+}
+/**
+ * Icon-only button that opens a menu of actions — the kebab / "more options"
+ * trigger. The glyph is fixed (Ellipsis); for any other icon use `ButtonIcon`.
+ * Pair it with the menu it controls and keep the `open` prop in sync.
+ */
+declare const ButtonIconMenu: React.ForwardRefExoticComponent<ButtonIconMenuProps & React.RefAttributes<HTMLButtonElement>>;
+export { ButtonIconMenu };

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

@@ -0,0 +1 @@
+export { ButtonIconMenu, type ButtonIconMenuProps } from './button-icon-menu';

package/dist/src/components/ui/button-menu/button-menu.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 buttonMenuVariants: (props?: ({
-    variant?: "primary" | "secondary" | null | undefined;
+    variant?: "secondary" | "primary" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface ButtonMenuProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'>, VariantProps<typeof buttonMenuVariants> {
     /**

package/dist/src/components/ui/calendar-panel/__tests__/calendar-panel-utils.test.d.ts

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

package/dist/src/components/ui/calendar-panel/calendar-panel-utils.d.ts

@@ -0,0 +1,55 @@
+import { CalendarPanelSelected, CalendarPanelVariant } from './calendar-panel';
+import { DayPickerLocale, DayPickerProps } from 'react-day-picker';
+/** Number of years offered on each side of the current year by default. */
+export declare const DEFAULT_YEAR_SPAN = 50;
+/** A `{value, label}` pair for one `InputSelect` option in the header dropdowns. */
+export interface CalendarSelectItem<T> {
+    value: T;
+    label: string;
+}
+/**
+ * Resolves the year dropdown's bounds: an explicit `fromYear`/`toYear` wins,
+ * otherwise falls back to `currentYear` ± `span`.
+ */
+export declare function resolveYearRange(fromYear: number | undefined, toYear: number | undefined, currentYear: number, span?: number): {
+    fromYear: number;
+    toYear: number;
+};
+/** Day-of-week index DayPicker accepts for `weekStartsOn` (0 = Sunday). */
+export type WeekStartsOn = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+/**
+ * Resolves the week's first day: an explicit `weekStartsOn` wins, then the
+ * `locale`'s own week start, then Monday (per the design default).
+ */
+export declare function resolveWeekStartsOn(weekStartsOn: WeekStartsOn | undefined, locale: DayPickerLocale | undefined): WeekStartsOn;
+/**
+ * Builds the 12 month dropdown items. Formats each from year 2000 (a leap
+ * year), so every month — including February 29 — formats from a valid date.
+ */
+export declare function buildMonthItems(formatMonthLabel: (date: Date) => string): CalendarSelectItem<number>[];
+/**
+ * Builds the year dropdown items spanning `fromYear`..`toYear` inclusive.
+ * An inverted range (`toYear < fromYear`) clamps to a single `fromYear` item
+ * rather than producing an empty or negative-length list.
+ */
+export declare function buildYearItems(fromYear: number, toYear: number): CalendarSelectItem<number>[];
+/**
+ * Backs a header-dropdown navigation target off so the last of `numberOfMonths`
+ * displayed months doesn't run past `endMonth`. Mirrors react-day-picker's own
+ * `getInitialMonth` back-off — its `goToMonth` only clamps the *first* displayed
+ * month to `endMonth`, so for a two-month `range` panel, requesting a first month
+ * within one month of `endMonth` (e.g. `endMonth` itself) leaves the second month
+ * past the bound, and `getDisplayMonths` silently drops it instead of the pair
+ * sliding back.
+ */
+export declare function clampNavigationTarget(target: Date, endMonth: Date, numberOfMonths: number): Date;
+/**
+ * Assembles DayPicker's mode-specific selection props from `variant`. DayPicker's
+ * props are a discriminated union keyed by a literal `mode`, so each branch is
+ * built separately (rather than a single object with `mode: variant`) — a
+ * literal tag is what lets TypeScript pick the matching union member without
+ * an `as DayPickerProps` assertion. `selected`/`onSelect` are cast per branch
+ * to their branch-specific shape only, which the discriminated `CalendarPanelProps`
+ * union above guarantees is safe at the call site.
+ */
+export declare function buildModeProps(variant: CalendarPanelVariant, selected: CalendarPanelSelected, onSelect: ((selected: CalendarPanelSelected, triggerDate: Date) => void) | undefined, min: number | undefined, max: number | undefined): DayPickerProps;

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

@@ -0,0 +1,112 @@
+import { DateRange, DayButton, DayPickerLocale, Matcher, MonthCaptionProps } from 'react-day-picker';
+import * as React from 'react';
+export type CalendarPanelVariant = 'single' | 'multiple' | 'range';
+/** Selected value, shaped by the active `variant`. */
+export type CalendarPanelSelected = Date | Date[] | DateRange | undefined;
+/**
+ * The header of one month column: a month `InputSelect` and a year `InputSelect`.
+ * Replaces DayPicker's `MonthCaption`.
+ */
+declare function CalendarHeader({ calendarMonth, displayIndex, className, ...props }: MonthCaptionProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CalendarHeader {
+    var displayName: string;
+}
+/**
+ * One day cell (Figma's "CalendarItem") — a flat 32×32 square. `data-active`
+ * (a selected day or either range endpoint) and `data-range-middle` are mutually
+ * exclusive, so their backgrounds never compete.
+ */
+declare function CalendarItem({ className, day, modifiers, ...props }: React.ComponentProps<typeof DayButton>): import("react/jsx-runtime").JSX.Element;
+declare namespace CalendarItem {
+    var displayName: string;
+}
+interface CalendarPanelSharedProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect' | 'defaultValue'> {
+    /**
+     * Text direction. Forwarded to `DayPicker` explicitly — an ancestor's `dir`
+     * mirrors the panel's CSS layout automatically (logical properties), but
+     * `react-day-picker` only flips its Arrow Left/Right keyboard roaming when
+     * `dir` is passed to it directly, so it must also be passed here.
+     */
+    dir?: 'ltr' | 'rtl';
+    /** Uncontrolled initial month shown. */
+    defaultMonth?: Date;
+    /** Controlled month shown (the first month, for `range`). */
+    month?: Date;
+    /** Called when the displayed month changes (header dropdowns). */
+    onMonthChange?: (month: Date) => void;
+    /** Days that cannot be selected. */
+    disabled?: Matcher | Matcher[];
+    /** Minimum count (`multiple` / `range`; ignored for `single`): for `multiple`, the number of selected dates; for `range`, the number of nights between start and end. */
+    min?: number;
+    /** Maximum count (`multiple` / `range`; ignored for `single`): for `multiple`, the number of selected dates; for `range`, the number of nights between start and end. */
+    max?: number;
+    /** Render the leading/trailing days of the adjacent months. */
+    showOutsideDays?: boolean;
+    /**
+     * First day of the week (0 = Sunday). Defaults to `locale`'s own week start,
+     * falling back to Monday (per the design) when no `locale` is given.
+     */
+    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    /**
+     * First year offered by the year dropdown and the earliest month the grid
+     * can navigate to. Defaults to 50 years back.
+     */
+    fromYear?: number;
+    /**
+     * Last year offered by the year dropdown and the latest month the grid can
+     * navigate to. Defaults to 50 years ahead.
+     */
+    toYear?: number;
+    /**
+     * Localizes weekday names and DayPicker's default day-cell/caption accessible
+     * labels (e.g. `import { es } from 'react-day-picker/locale'`). Defaults to
+     * date-fns `enUS`. Does not translate `monthLabel`/`yearLabel`/`cancelLabel`/
+     * `applyLabel`/`formatMonthLabel` — those are separate props the consumer
+     * must localize themselves.
+     */
+    locale?: DayPickerLocale;
+    /** Accessible name of the month dropdown. */
+    monthLabel?: string;
+    /** Accessible name of the year dropdown. */
+    yearLabel?: string;
+    /** Formats a month's name for the month dropdown. Defaults to `locale`-aware `date-fns` formatting. */
+    formatMonthLabel?: (date: Date) => string;
+    /** Footer "Cancel" button label (`multiple` / `range`). */
+    cancelLabel?: string;
+    /** Footer "Apply" button label (`multiple` / `range`). */
+    applyLabel?: string;
+    /** Called when the footer's Cancel button is pressed. */
+    onCancel?: () => void;
+    /** Called when the footer's Apply button is pressed. */
+    onApply?: () => void;
+}
+/** `variant="single"` (the default) — `selected` is a single optional `Date`. */
+export interface CalendarPanelSingleProps extends CalendarPanelSharedProps {
+    /** Selection mode + panel structure. `multiple`/`range` add the Cancel/Apply footer; `range` shows two months. */
+    variant?: 'single';
+    /** The selected date. Uncontrolled unless `onSelect` is provided. */
+    selected?: Date;
+    /** Called when the selection changes. Providing it makes `selected` controlled. */
+    onSelect?: (selected: Date | undefined, triggerDate: Date) => void;
+}
+/** `variant="multiple"` — `selected` is a `Date[]`, and the footer is shown. */
+export interface CalendarPanelMultipleProps extends CalendarPanelSharedProps {
+    variant: 'multiple';
+    selected?: Date[];
+    onSelect?: (selected: Date[] | undefined, triggerDate: Date) => void;
+}
+/** `variant="range"` — `selected` is a `DateRange`, two months render, and the footer is shown. */
+export interface CalendarPanelRangeProps extends CalendarPanelSharedProps {
+    variant: 'range';
+    selected?: DateRange;
+    onSelect?: (selected: DateRange | undefined, triggerDate: Date) => void;
+}
+/**
+ * `CalendarPanel`'s props, discriminated by `variant` — a `single` panel only
+ * accepts a `Date`, `multiple` only a `Date[]`, `range` only a `DateRange`, so
+ * mismatched `selected`/`onSelect` shapes are caught at the call site instead
+ * of silently reaching `react-day-picker` with the wrong shape at runtime.
+ */
+export type CalendarPanelProps = CalendarPanelSingleProps | CalendarPanelMultipleProps | CalendarPanelRangeProps;
+declare const CalendarPanel: React.ForwardRefExoticComponent<CalendarPanelProps & React.RefAttributes<HTMLDivElement>>;
+export { CalendarPanel, CalendarItem, CalendarHeader };

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

@@ -0,0 +1 @@
+export { CalendarPanel, CalendarItem, CalendarHeader, type CalendarPanelProps, type CalendarPanelSingleProps, type CalendarPanelMultipleProps, type CalendarPanelRangeProps, type CalendarPanelSelected, type CalendarPanelVariant, } from './calendar-panel';

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

@@ -1,7 +1,7 @@
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const chipVariants: (props?: ({
-    variant?: "removable" | "selectable" | null | undefined;
+    variant?: "removable" | "selectable" | "operational" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface ChipProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof chipVariants> {
     /** Optional leading icon, rendered at 16px before the label. */

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

@@ -1,32 +1,26 @@
+import { DayPickerLocale } from 'react-day-picker';
 /** 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. */
+/**
+ * The date display pattern used by the trigger. Fixed month-day-year order
+ * regardless of `locale` — only the month/day/era token *names* localize (see
+ * {@link formatDate}); true locale-aware reordering is a separate, bigger
+ * change (tracked, not done here).
+ */
 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.
+ * `locale` only translates the month name via `date-fns`' `format` `options`
+ * — it does not reorder `DISPLAY_FORMAT`'s fixed month-day-year pattern.
  */
-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;
+export declare function formatDate(date: Date | undefined, locale?: DayPickerLocale): string;
 /**
  * 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

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

@@ -1,10 +1,11 @@
+import { DayPickerLocale, Matcher } from 'react-day-picker';
 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". */
+    /** The initial applied range (uncontrolled). */
     defaultValue?: DateRange;
     /** Called with the committed range when Apply is pressed. */
     onValueChange?: (range: DateRange) => void;
@@ -20,8 +21,51 @@ export interface DateRangePickerProps {
     disabled?: boolean;
     /** Marks the trigger required. */
     required?: boolean;
-    /** Extra classes merged onto the trigger. */
+    /** Extra classes merged onto the trigger's field wrapper (label + box + message). */
     className?: string;
+    /** Days that cannot be selected in the calendar. */
+    disabledDays?: Matcher | Matcher[];
+    /** Minimum number of nights between the range's start and end (`differenceInCalendarDays(to, from)`) — e.g. `min={7}` requires at least 8 selectable days. */
+    min?: number;
+    /** Maximum number of nights between the range's start and end (`differenceInCalendarDays(to, from)`) — e.g. `max={31}` admits up to 32 selectable days. */
+    max?: number;
+    /** Render the leading/trailing days of the adjacent months. */
+    showOutsideDays?: boolean;
+    /**
+     * First day of the week (0 = Sunday). Defaults to `locale`'s own week
+     * start, falling back to Monday when no `locale` is given.
+     */
+    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    /**
+     * First year offered by the year dropdown and the earliest month the grid
+     * can navigate to. Defaults to 50 years back.
+     */
+    fromYear?: number;
+    /**
+     * Last year offered by the year dropdown and the latest month the grid can
+     * navigate to. Defaults to 50 years ahead.
+     */
+    toYear?: number;
+    /**
+     * Localizes weekday names, the calendar's default day-cell/caption
+     * accessible labels, and the trigger's month name (e.g. `import { es }
+     * from 'react-day-picker/locale'`). The trigger's day/year order stays
+     * fixed (`MMM d, yyyy`) — only the month name translates, not the
+     * ordering. Defaults to date-fns `enUS`. Does not translate `monthLabel`/
+     * `yearLabel`/`cancelLabel`/`applyLabel`/`formatMonthLabel` — those are
+     * separate props.
+     */
+    locale?: DayPickerLocale;
+    /** Accessible name of the calendar's month dropdown. */
+    monthLabel?: string;
+    /** Accessible name of the calendar's year dropdown. */
+    yearLabel?: string;
+    /** Formats a month's name for the month dropdown. Defaults to `locale`-aware `date-fns` formatting. */
+    formatMonthLabel?: (date: Date) => string;
+    /** Popup footer's "Cancel" button label. */
+    cancelLabel?: string;
+    /** Popup footer's "Apply" button label. */
+    applyLabel?: string;
 }
 declare const DateRangePicker: React.ForwardRefExoticComponent<DateRangePickerProps & React.RefAttributes<HTMLButtonElement>>;
 export { DateRangePicker };

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

@@ -29,4 +29,11 @@ declare function DropdownMenuShortcut({ className, ...props }: React.HTMLAttribu
 declare namespace DropdownMenuShortcut {
     var displayName: string;
 }
-export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuPortal, };
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuCheckboxItemProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const DropdownMenuRadioGroup: React.NamedExoticComponent<Omit<import('@base-ui/react').ContextMenuRadioGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+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>>;
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuPortal, };

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

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

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

@@ -0,0 +1,11 @@
+import { useRender } from '@base-ui/react/use-render';
+import * as React from 'react';
+export interface FilterCardsProps extends React.ComponentPropsWithoutRef<'div'> {
+    /**
+     * Replace the rendered `<div>` with another element or component
+     * (Base UI composition).
+     */
+    render?: useRender.RenderProp;
+}
+declare const FilterCards: React.ForwardRefExoticComponent<FilterCardsProps & React.RefAttributes<HTMLDivElement>>;
+export { FilterCards };

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

@@ -0,0 +1 @@
+export { FilterCards, type FilterCardsProps } from './filter-cards';

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

@@ -0,0 +1,25 @@
+import { useRender } from '@base-ui/react/use-render';
+import * as React from 'react';
+export interface FilterChipsProps extends React.ComponentPropsWithoutRef<'div'> {
+    /**
+     * Replace the rendered `<div>` with another element or component
+     * (Base UI composition). Accepts a React element or a render function.
+     */
+    render?: useRender.RenderProp;
+    /** Accessible name for the applied-filter region. */
+    ariaLabel?: string;
+}
+declare const FilterChips: React.ForwardRefExoticComponent<FilterChipsProps & React.RefAttributes<HTMLDivElement>>;
+export type FilterChipsListProps = React.ComponentPropsWithoutRef<'div'>;
+declare const FilterChipsList: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export interface FilterChipsResetProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * Replace the rendered `<button>` with another element or component
+     * (Base UI composition). Accepts a React element or a render function.
+     */
+    render?: useRender.RenderProp;
+    /** Label for the reset action. */
+    children?: React.ReactNode;
+}
+declare const FilterChipsReset: React.ForwardRefExoticComponent<FilterChipsResetProps & React.RefAttributes<HTMLButtonElement>>;
+export { FilterChips, FilterChipsList, FilterChipsReset };

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

@@ -0,0 +1 @@
+export { FilterChips, FilterChipsList, FilterChipsReset, type FilterChipsProps, type FilterChipsListProps, type FilterChipsResetProps, } from './filter-chips';

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

@@ -1,3 +1,5 @@
+import { FilterChipsProps } from '../filter-chips';
+import { PopoverContent } from '../popover';
 import * as React from 'react';
 export type FilterSearchProps = React.ComponentPropsWithoutRef<'div'>;
 declare const FilterSearch: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
@@ -25,6 +27,12 @@ export interface FilterSearchFiltersProps extends Omit<React.ComponentPropsWitho
     onApply?: (filters: Record<string, unknown>) => void;
     /** Label for the filter trigger button. */
     label?: React.ReactNode;
+    /** Label for the "Reset filters" action inside the popover. */
+    resetFiltersLabel?: React.ReactNode;
+    /** Label for the "Cancel" action inside the popover. */
+    cancelLabel?: React.ReactNode;
+    /** Label for the "Apply" action inside the popover. */
+    applyLabel?: React.ReactNode;
     /**
      * Filter field children rendered inside the popover form. Plain children —
      * wire each field to the draft via `useFilterSearchFilters`. Group fields with
@@ -33,15 +41,45 @@ export interface FilterSearchFiltersProps extends Omit<React.ComponentPropsWitho
     children?: React.ReactNode;
     /** Additional classes merged onto the trigger button. */
     className?: string;
+    /** Additional classes merged onto the popover content. */
+    contentClassName?: string;
+    /** Which side of the trigger to render the popover on. Defaults to `'bottom'`. */
+    side?: React.ComponentProps<typeof PopoverContent>['side'];
+    /** Alignment of the popover along the chosen side. Defaults to `'start'`. */
+    align?: React.ComponentProps<typeof PopoverContent>['align'];
+    /** Distance in px between the trigger and the popover. */
+    sideOffset?: React.ComponentProps<typeof PopoverContent>['sideOffset'];
+    /**
+     * Portal container the popover mounts into. Defaults to the nearest
+     * `PortalContainerProvider`, or `document.body` if none is set — see
+     * `PopoverContent`'s `portalContainer` prop.
+     */
+    portalContainer?: React.ComponentProps<typeof PopoverContent>['portalContainer'];
+    /**
+     * Element/rect the popover is confined to when avoiding collisions. See
+     * `PopoverContent`'s `collisionBoundary` prop for the default behavior
+     * inside a constrained portal container.
+     */
+    collisionBoundary?: React.ComponentProps<typeof PopoverContent>['collisionBoundary'];
+    /**
+     * Which CSS `position` the popover uses. See `PopoverContent`'s
+     * `positionMethod` prop for the default behavior inside a constrained
+     * portal container.
+     */
+    positionMethod?: React.ComponentProps<typeof PopoverContent>['positionMethod'];
 }
 declare const FilterSearchFilters: React.ForwardRefExoticComponent<FilterSearchFiltersProps & React.RefAttributes<HTMLButtonElement>>;
-export interface FilterSearchAppliedFiltersProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
+export interface FilterSearchAppliedFiltersProps extends Omit<FilterChipsProps, '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;
+    /** Format a filter chip's remove-button accessible label. Defaults to `"Remove <key> filter"`. */
+    getRemoveFilterLabel?: (key: string) => string;
+    /** Label for the "Reset filters" action. */
+    resetFiltersLabel?: React.ReactNode;
 }
 /**
  * Renders one removable chip per applied filter plus a "Reset filters" action