@acronis-platform/ui-react 0.60.0 → 0.62.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/area-chart/area-chart.d.ts

@@ -1,11 +1,39 @@
 import { VariantProps } from 'class-variance-authority';
-import { ChartConfig, CartesianChartProps } from '../chart';
+import { ChartConfig, CartesianChartProps, ChartAnimationProps, ChartBrushProps, ChartCurveType, ChartDataLabelProps, ChartReferenceLine, CartesianLabelPosition } from '../chart';
 import * as React from 'react';
 declare const areaChartVariants: (props?: ({
     layout?: "single" | "stacked" | null | undefined;
     fill?: "solid" | "gradient" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-export interface AreaChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, VariantProps<typeof areaChartVariants>, CartesianChartProps {
+/**
+ * Style override for one series, keyed by its `dataKeys` entry. Anything left
+ * unset falls back to the chart-wide prop, so an entry only states what differs
+ * — e.g. a projection band that reads fainter than the actuals beside it.
+ */
+export interface AreaChartAreaSettings {
+    /** Stroke and fill color. Defaults to the series' `config` color. */
+    color?: string;
+    /** Width of this series' top border. Defaults to the chart's `strokeWidth`. */
+    strokeWidth?: number;
+    /** Dash this series' top border. */
+    dashed?: boolean;
+    /** Interpolation for this series only. Defaults to the chart's `curve`. */
+    curveType?: ChartCurveType;
+    /**
+     * Fill opacity for this series. Under `fill="gradient"` it scales the
+     * gradient's own alpha rather than replacing it.
+     */
+    fillOpacity?: number;
+    /** Render this series' per-point dots. Defaults to the chart's `showDots`. */
+    showDots?: boolean;
+    /** Dot radius for this series, in px. Defaults to the chart's `dotSize`. */
+    dotSize?: number;
+    /** Show/hide this series' value labels, overriding the chart's `showLabels`. */
+    showLabel?: boolean;
+    /** Position of this series' value labels. Defaults to the chart's `labelPosition`. */
+    labelPosition?: CartesianLabelPosition;
+}
+export interface AreaChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, VariantProps<typeof areaChartVariants>, CartesianChartProps, ChartAnimationProps, ChartBrushProps, ChartDataLabelProps {
     /** Row-per-point data. Each object holds the category key + one numeric field per series (`null` breaks the area unless `connectNulls`). */
     data: ReadonlyArray<Record<string, string | number | null>>;
     /**
@@ -19,16 +47,38 @@ export interface AreaChartProps extends Omit<React.ComponentProps<'div'>, 'child
     /** Category axis key (the shared dimension across rows, e.g. `"month"`). */
     xKey: string;
     /** Interpolation between points. */
-    curve?: 'linear' | 'monotone' | 'step';
+    curve?: ChartCurveType;
     /** Stroke width of each area's top border. */
     strokeWidth?: number;
     /** Flat-fill opacity — used only when `fill="solid"` (gradient controls its own stops). */
     fillOpacity?: number;
     /** Render a dot at each data point. */
     showDots?: boolean;
+    /** Radius of each point's dot, in px. Its hover dot is 2px larger. */
+    dotSize?: number;
+    /**
+     * Enlarge the hovered point's dot. Defaults to following `showDots`, so pass
+     * it explicitly to get hover dots on a dot-less area (`showDots={false}` with
+     * `showActiveDot`) or a static-only area (dots without the hover one).
+     */
+    showActiveDot?: boolean;
     /** Bridge `null` gaps in the data instead of breaking the area. */
     connectNulls?: boolean;
+    /**
+     * Per-series style overrides, keyed by `dataKeys` entry. Series with no entry
+     * render from the chart-wide props.
+     */
+    areaSettings?: Record<string, AreaChartAreaSettings>;
+    /**
+     * One or more dashed reference/average lines on the value axis — a target, a
+     * threshold, or a series mean. Pass a single object or an array to draw
+     * several at once. On a stacked chart the value is read against the stack's
+     * axis, not one series.
+     */
+    referenceLine?: ChartReferenceLine | ChartReferenceLine[];
     showLegend?: boolean;
+    /** Position of the value labels when `showLabels` is on. Defaults to `top`. */
+    labelPosition?: CartesianLabelPosition;
 }
 declare const AreaChart: React.ForwardRefExoticComponent<Omit<AreaChartProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export { AreaChart, areaChartVariants };

package/dist/src/components/ui/area-chart/index.d.ts

@@ -1 +1 @@
-export { AreaChart, areaChartVariants, type AreaChartProps } from './area-chart';
+export { AreaChart, areaChartVariants, type AreaChartProps, type AreaChartAreaSettings, } from './area-chart';

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

@@ -2,7 +2,7 @@ import { Avatar as AvatarPrimitive } from '@base-ui/react/avatar';
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const avatarVariants: (props?: ({
-    color?: "orange" | "red" | "teal" | "violet" | "yellow" | null | undefined;
+    color?: "blue" | "gray" | "green" | "orange" | "red" | "teal" | "violet" | "yellow" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface AvatarProps extends React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root>, VariantProps<typeof avatarVariants> {
 }

package/dist/src/components/ui/bar-chart/bar-chart.d.ts

@@ -1,30 +1,123 @@
 import { VariantProps } from 'class-variance-authority';
-import { ChartConfig, CartesianChartProps } from '../chart';
+import { BarShapeProps } from 'recharts/types/cartesian/Bar';
+import { ChartLegend, ChartTooltip, ChartConfig, ChartReferenceLine, CartesianChartProps, ChartAnimationProps, ChartBrushProps, ChartCategoryRange, ChartDataLabelProps, CartesianLabelPosition } from '../chart';
 import * as React from 'react';
 declare const barChartVariants: (props?: ({
     orientation?: "horizontal" | "vertical" | null | undefined;
     layout?: "stacked" | "grouped" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-export interface BarChartReferenceLine {
-    /** Fixed position on the value axis. Takes precedence over `average`. */
-    value?: number;
+/**
+ * How a bar is painted. `rounded` rounds the growing end by `barRadius`; `pill`
+ * rounds every corner to a capsule; `gradient` fades the series color down the
+ * bar; `pattern` fills it with diagonal hatching in the series color (a
+ * colorblind-safe way to set a subset of bars apart).
+ */
+export type BarChartBarShape = 'rounded' | 'pill' | 'gradient' | 'pattern';
+/**
+ * Style override for one series over a range of categories — e.g. "the forecast
+ * tail from September onward reads translucent and dashed". Anything left unset
+ * keeps the series' normal painting.
+ */
+export interface BarChartBarSettings extends ChartCategoryRange {
+    /** Fill for the matched bars. Defaults to the series color. */
+    fill?: string;
+    /** Fill opacity for the matched bars. */
+    opacity?: number;
+    /** Outline the matched bars with a dashed stroke in the series color. */
+    dashed?: boolean;
+    /** Shape for the matched bars, overriding the chart's `barShape`. */
+    shape?: BarChartBarShape;
     /**
-     * Draw the line at the mean of one series (a `dataKeys` entry) or, when
-     * `true`, of every plotted series' values.
+     * Track behind the matched bars: `true` fills the plot height, while a data
+     * field name caps it at that row's value — the headroom between a projection
+     * and its upper bound. A capped track stacks on its bar, so it needs the
+     * default `layout="grouped"`; under `layout="stacked"` it is ignored.
      */
-    average?: boolean | string;
-    /** Optional caption rendered alongside the line. */
+    background?: boolean | string;
+}
+/** A shaded band behind a range of categories. */
+export interface BarChartReferenceArea extends ChartCategoryRange {
+    /** Caption above the band. */
     label?: string;
+    /**
+     * Mark the category ticks under the band — accent color, italic — so the
+     * highlighted range reads on the axis too. On by default.
+     */
+    highlightTicks?: boolean;
+    /**
+     * Draw a dashed rule at the band's leading edge — the hand-off into a
+     * forecast. Off by default.
+     */
+    divider?: boolean;
 }
 /**
- * Resolve a `referenceLine` config to a position on the value axis: a fixed
- * `value` wins; otherwise the mean of the requested series (a single `dataKeys`
- * entry, or all of them when `average` is `true`). Returns `undefined` when
- * there is nothing to draw (no config, or no numeric values to average).
- * Exported for unit tests; not part of the package's public API.
+ * Drop the synthetic headroom series from a recharts tooltip/legend payload,
+ * keeping the real series (and their order). `legendType`/`tooltipType="none"`
+ * are set on those bars too, but recharts still lists them, so this filter is
+ * what actually keeps them out — hence it's unit-tested.
+ */
+export declare function dropHeadroomSeries<T extends {
+    dataKey?: unknown;
+}>(payload: readonly T[] | undefined, dataKeys?: string[]): T[] | undefined;
+/**
+ * Swap a paint-server fill back to the series color for the chrome. A
+ * `gradient` / `pattern` bar fills from `url(#…)`, which paints SVG but means
+ * nothing as a CSS background — the legend swatch and the tooltip dot would
+ * render blank — so they fall back to the series' own `--color-<key>`.
  */
-export declare function barChartReferenceValue(referenceLine: BarChartReferenceLine | undefined, data: ReadonlyArray<Record<string, string | number>>, dataKeys: string[]): number | undefined;
-export interface BarChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, VariantProps<typeof barChartVariants>, CartesianChartProps {
+export declare function withSeriesColor<T extends {
+    dataKey?: unknown;
+    color?: string;
+}>(payload: readonly T[] | undefined): T[] | undefined;
+type TooltipContentType = NonNullable<React.ComponentProps<typeof ChartTooltip>['content']>;
+type TooltipContentFn = Extract<TooltipContentType, (...args: never[]) => unknown>;
+type TooltipRenderProps = Parameters<TooltipContentFn>[0];
+type LegendContentType = NonNullable<React.ComponentProps<typeof ChartLegend>['content']>;
+type LegendContentFn = Extract<LegendContentType, (...args: never[]) => unknown>;
+type LegendRenderProps = Parameters<LegendContentFn>[0];
+/**
+ * Tooltip content that normalizes recharts' payload before anything renders it:
+ * the synthetic headroom series stripped, the rows put back in `dataKeys` order,
+ * and paint-server fills swapped back to the series color. Falls through to a
+ * caller-supplied `content`, preserving recharts' own mount semantics — a
+ * function via `createElement` (its own component identity + hook state), an
+ * element via `cloneElement`.
+ *
+ * This is a component rather than a per-render wrapper factory on purpose:
+ * recharts renders `content` by cloning the element it is given
+ * (`Tooltip.js:27-28`), so a stable module-level type here means the subtree is
+ * never remounted, whatever the caller passes.
+ */
+export declare function NormalizedTooltipContent({ content, dataKeys, ...props }: Partial<TooltipRenderProps> & {
+    content?: TooltipContentType;
+    dataKeys?: string[];
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Legend content over the same normalization. Ordering is the reason this
+ * applies unconditionally: recharts sorts legend entries alphabetically by
+ * series name by default (`itemSorter: 'value'`), so without putting them back
+ * in `dataKeys` order the legend would silently reorder itself depending on
+ * which bar-styling props happen to be set.
+ */
+export declare function NormalizedLegendContent({ dataKeys, ...props }: Partial<LegendRenderProps> & {
+    dataKeys: string[];
+}): import("react/jsx-runtime").JSX.Element;
+/** Paint overrides recharts spreads over a bar to mark it as the active one. */
+interface BarPaintOverride {
+    fill?: string;
+    fillOpacity?: number;
+}
+/**
+ * Build the `<Bar shape>` that draws a range-scoped track. recharts' own
+ * `background` is all-or-nothing per series, so the track is drawn per row and
+ * hidden where the range doesn't apply.
+ */
+export declare function createTrackShape({ inRange, trackFill, paint, }: {
+    inRange: (row: number) => boolean;
+    trackFill: string;
+    paint?: BarPaintOverride;
+}): ({ background: track, index: row, ...bar }: BarShapeProps) => import("react/jsx-runtime").JSX.Element;
+export interface BarChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, VariantProps<typeof barChartVariants>, CartesianChartProps, ChartAnimationProps, ChartBrushProps, ChartDataLabelProps {
     /** Row-per-category data. Each object holds the category key + one numeric field per series. */
     data: ReadonlyArray<Record<string, string | number>>;
     /**
@@ -42,12 +135,57 @@ export interface BarChartProps extends Omit<React.ComponentProps<'div'>, 'childr
      * bars, X for horizontal). Each is driven by a fixed `value` or a computed
      * series `average`. Pass a single object or an array to draw several at once.
      */
-    referenceLine?: BarChartReferenceLine | BarChartReferenceLine[];
+    referenceLine?: ChartReferenceLine | ChartReferenceLine[];
+    /**
+     * One or more shaded bands behind a range of categories — e.g. a forecast
+     * period. Pass a single object or an array to draw several.
+     */
+    referenceArea?: BarChartReferenceArea | BarChartReferenceArea[];
+    /**
+     * Per-series style override for a range of categories, keyed by `dataKeys`
+     * entry. Bars outside a series' range — and series with no entry — render
+     * normally.
+     */
+    barSettings?: Record<string, BarChartBarSettings>;
     /** Unit suffix on X-axis tick values (recharts `unit`) — applies when the X axis is numeric (`orientation="horizontal"`). */
     xUnit?: string;
     /** Corner radius applied to the growing end of each bar. */
     barRadius?: number;
+    /** How every bar is painted. Per-range overrides come from `barSettings`. */
+    barShape?: BarChartBarShape;
+    /** Fixed bar thickness, in px. Unset, recharts sizes bars from the available width. */
+    barSize?: number;
+    /** Upper bound on the computed bar thickness, in px. */
+    maxBarSize?: number;
+    /** Gap between bars of the same category, in px or a percentage string. */
+    barGap?: number | string;
+    /** Gap between category groups, in px or a percentage string. */
+    barCategoryGap?: number | string;
+    /**
+     * Minimum rendered length for a bar, in px, so a tiny value stays visible. A
+     * value of exactly `0` still renders nothing — a floor on it would read as a
+     * small positive.
+     */
+    minPointSize?: number;
+    /** Draw a full-height track behind every bar. */
+    showBackground?: boolean;
+    /** Fill for the track background. Defaults to the secondary surface. */
+    backgroundFill?: string;
+    /** Highlight the hovered bar. */
+    showActiveBar?: boolean;
+    /** Painting of the hovered bar when `showActiveBar` is on. */
+    activeBar?: {
+        /** Fill for the hovered bar. Defaults to the series color. */
+        fill?: string;
+        /** Fill opacity for the hovered bar. */
+        opacity?: number;
+    };
     showLegend?: boolean;
+    /**
+     * Position of the value labels when `showLabels` is on. Defaults to the growing
+     * end — `top` for vertical bars, `right` for horizontal.
+     */
+    labelPosition?: CartesianLabelPosition;
 }
 declare const BarChart: React.ForwardRefExoticComponent<Omit<BarChartProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export { BarChart, barChartVariants };

package/dist/src/components/ui/bar-chart/index.d.ts

@@ -1 +1 @@
-export { BarChart, barChartVariants, type BarChartProps, type BarChartReferenceLine, } from './bar-chart';
+export { BarChart, barChartVariants, type BarChartProps, type BarChartReferenceArea, type BarChartBarSettings, type BarChartBarShape, } from './bar-chart';

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" | null | undefined;
+    variant?: "destructive" | "ai" | "secondary" | "default" | "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/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?: "secondary" | "primary" | null | undefined;
+    variant?: "primary" | "secondary" | 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 number of selectable days (`multiple` / `range`; ignored for `single`). */
+    min?: number;
+    /** Maximum number of selectable days (`multiple` / `range`; ignored for `single`). */
+    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/chart/__tests__/chart-layout.d.ts

@@ -0,0 +1,63 @@
+/** Width the faked layout reports to recharts. */
+export declare const CHART_WIDTH = 600;
+/** Height the faked layout reports to recharts. */
+export declare const CHART_HEIGHT = 400;
+/**
+ * Give recharts a laid-out container for the duration of the calling test.
+ *
+ * recharts' `ResponsiveContainer` measures its box through a `ResizeObserver`,
+ * which happy-dom never fires, and reads `getBoundingClientRect()` once in its
+ * effect — so by default the chart renders at 0×0 and every SVG child bails out.
+ * Feeding it a size is what makes the axes, grid and series observable in a unit
+ * test at all; without it the only honest assertion left is "the chart root
+ * exists", which passes whether or not the feature works.
+ *
+ * Only the responsive container may report the size. recharts also measures the
+ * legend wrapper; if that reported the full height too, it would claim the whole
+ * plot area and the series would again render at zero height.
+ *
+ * happy-dom defines the rect once, on `Element.prototype` — patching that one
+ * prototype covers every element type, and patching a subclass's prototype as
+ * well would capture this wrapper as its own "original" and leave it installed
+ * after the restore.
+ *
+ * Call it inside the test, before rendering. Cleanup is registered automatically,
+ * so no `afterEach` is needed at the call site. Calling it more than once in the
+ * same test (a loop that renders one chart per case) re-stubs nothing — that
+ * would capture this wrapper as its own "original" — though each call does queue
+ * its own teardown, and the second one finds the patches already lifted.
+ */
+export declare function giveTheChartASize(): void;
+/**
+ * Suite-level form of `giveTheChartASize`, for a file where every case renders a
+ * laid-out chart — including the ones that call `render()` directly instead of
+ * going through a shared `renderChart` helper. Call it once at the top of the
+ * file; it registers its own `beforeEach`/`afterEach`, so the size is in place
+ * whichever way a case renders and is torn down between cases either way.
+ */
+export declare function giveEveryChartASize(): void;
+/**
+ * The tick elements recharts painted for one cartesian axis, in document order.
+ *
+ * Selected by recharts' own `orientation` attribute rather than by descending
+ * from `.recharts-xAxis` / `.recharts-yAxis`, because as of recharts 3.8 a tick
+ * is not inside its axis group at all: the labels are hoisted into a separate
+ * top-level `recharts-zIndex-layer_*` that is a *sibling* of the axis. So
+ * `.recharts-xAxis .recharts-text` matches nothing and `axis.contains(tick)` is
+ * false — and a test written the obvious way passes vacuously instead of
+ * asserting anything. (Descendant selectors themselves are fine here; `svg text`
+ * and `clipPath rect` both work.)
+ *
+ * `'x'` and `'y'` mean *both* axes of that dimension, so on a chart with a
+ * secondary scale they return the two axes' ticks concatenated. Pass a single
+ * side (`'left'`, `'right'`, `'top'`, `'bottom'`) to assert against one of them
+ * — the orientation attribute is the only thing separating them.
+ *
+ * An empty result means "no tick carried that orientation", which is also what
+ * you get if a recharts upgrade stops emitting the attribute. Assert a length
+ * before looping, or a broken selector reads as a chart with no ticks.
+ */
+export type ChartAxisSide = 'left' | 'right' | 'top' | 'bottom';
+export declare function axisTicks(container: Element, axis: 'x' | 'y' | ChartAxisSide): Element[];
+/** Text of every tick on one cartesian axis — see `axisTicks` for the caveats. */
+export declare function axisTickLabels(container: Element, axis: 'x' | 'y' | ChartAxisSide): (string | null)[];

package/dist/src/components/ui/chart/__tests__/chart-layout.test.d.ts

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