@acronis-platform/ui-react 0.57.1 → 0.60.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

@@ -0,0 +1,34 @@
+import { VariantProps } from 'class-variance-authority';
+import { ChartConfig, CartesianChartProps } 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 {
+    /** 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>>;
+    /**
+     * Per-series map of `label` / `color` (imported from the shared `Chart`
+     * primitives). Series colors are caller-supplied — reference an existing
+     * semantic `--ui-*` token; there is no chart palette tier yet.
+     */
+    config: ChartConfig;
+    /** Series to plot — one `<Area>` per key. Each must exist in `config` and in every data row. */
+    dataKeys: string[];
+    /** Category axis key (the shared dimension across rows, e.g. `"month"`). */
+    xKey: string;
+    /** Interpolation between points. */
+    curve?: 'linear' | 'monotone' | 'step';
+    /** 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;
+    /** Bridge `null` gaps in the data instead of breaking the area. */
+    connectNulls?: boolean;
+    showLegend?: boolean;
+}
+declare const AreaChart: React.ForwardRefExoticComponent<Omit<AreaChartProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { AreaChart, areaChartVariants };

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

@@ -0,0 +1 @@
+export { AreaChart, areaChartVariants, type AreaChartProps } 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?: "teal" | "violet" | "red" | "yellow" | "orange" | null | undefined;
+    color?: "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,11 +1,30 @@
 import { VariantProps } from 'class-variance-authority';
-import { ChartConfig } from '../chart';
+import { ChartConfig, CartesianChartProps } from '../chart';
 import * as React from 'react';
 declare const barChartVariants: (props?: ({
     orientation?: "horizontal" | "vertical" | null | undefined;
-    layout?: "grouped" | "stacked" | null | undefined;
+    layout?: "stacked" | "grouped" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-export interface BarChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, VariantProps<typeof barChartVariants> {
+export interface BarChartReferenceLine {
+    /** Fixed position on the value axis. Takes precedence over `average`. */
+    value?: number;
+    /**
+     * Draw the line at the mean of one series (a `dataKeys` entry) or, when
+     * `true`, of every plotted series' values.
+     */
+    average?: boolean | string;
+    /** Optional caption rendered alongside the line. */
+    label?: string;
+}
+/**
+ * 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.
+ */
+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 {
     /** Row-per-category data. Each object holds the category key + one numeric field per series. */
     data: ReadonlyArray<Record<string, string | number>>;
     /**
@@ -18,10 +37,16 @@ export interface BarChartProps extends Omit<React.ComponentProps<'div'>, 'childr
     dataKeys: string[];
     /** Category axis key (the shared dimension across rows, e.g. `"month"`). */
     xKey: string;
+    /**
+     * One or more dashed reference/average lines on the value axis (Y for vertical
+     * 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[];
+    /** 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;
-    showGrid?: boolean;
-    showTooltip?: boolean;
     showLegend?: boolean;
 }
 declare const BarChart: React.ForwardRefExoticComponent<Omit<BarChartProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

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

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

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

@@ -0,0 +1,21 @@
+import { useRender } from '@base-ui/react/use-render';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const buttonIconInputVariants: (props?: ({
+    variant?: "error" | "normal" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ButtonIconInputProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonIconInputVariants> {
+    /**
+     * 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;
+}
+/**
+ * Small icon-only button meant to sit inside an input's box. The icon is
+ * passed as `children`; provide an `aria-label` (or `aria-labelledby`) so the
+ * control has an accessible name.
+ */
+declare const ButtonIconInput: React.ForwardRefExoticComponent<ButtonIconInputProps & React.RefAttributes<HTMLButtonElement>>;
+export { ButtonIconInput, buttonIconInputVariants };

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

@@ -0,0 +1 @@
+export { ButtonIconInput, buttonIconInputVariants, type ButtonIconInputProps, } from './button-icon-input';

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

@@ -11,6 +11,11 @@ export interface CardFilterProps extends Omit<React.HTMLAttributes<HTMLElement>,
     value?: React.ReactNode;
     /** Optional leading icon (16px) rendered before the value. Hidden for `static-empty`. */
     icon?: React.ReactNode;
+    /**
+     * `clickable` only — applies the selected (active) styling and exposes the
+     * card as a pressed toggle (`aria-pressed`). Controlled only.
+     */
+    selected?: boolean;
     /**
      * Replace the rendered element (`<button>` for `clickable`, otherwise `<div>`)
      * with another element or component (Base UI composition) — e.g. a router link

package/dist/src/components/ui/carousel-dialog/carousel-dialog.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+export type CarouselDialogVariant = 'first' | 'middle' | 'last';
+export interface CarouselDialogProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Which slide position this renders for. Defaults to `'first'`. */
+    variant?: CarouselDialogVariant;
+    /** Total number of slides, used to render the dot `ListIndicator`. Defaults to `1`. */
+    slideCount?: number;
+    /** The currently active slide index (0-based). Defaults to `0`. */
+    selectedIndex?: number;
+    /** Fires when a dot is activated, with the dot's slide index. */
+    onSelectIndex?: (index: number) => void;
+    /** Fires when `Back` (hidden on `variant="first"`) is activated. */
+    onBack?: () => void;
+    /** Fires when `Next` (`variant="first" | "middle"`) is activated. */
+    onNext?: () => void;
+    /** Fires when the call-to-action button (`variant="last"`) is activated. */
+    onPrimaryAction?: () => void;
+    /** `Back` button label. Defaults to `'Back'`. */
+    backLabel?: string;
+    /** `Next` button label (`variant="first" | "middle"`). Defaults to `'Next'`. */
+    nextLabel?: string;
+    /** Call-to-action button label (`variant="last"`). Defaults to `'Call to action'`. */
+    primaryLabel?: string;
+    /** Builds each dot's accessible name from its 0-based index and the slide count. */
+    goToSlideLabel?: (index: number, count: number) => string;
+}
+declare const CarouselDialog: React.ForwardRefExoticComponent<CarouselDialogProps & React.RefAttributes<HTMLDivElement>>;
+export { CarouselDialog };

package/dist/src/components/ui/carousel-dialog/index.d.ts

@@ -0,0 +1 @@
+export { CarouselDialog, type CarouselDialogProps, type CarouselDialogVariant, } from './carousel-dialog';

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

@@ -0,0 +1,51 @@
+import { VariantProps } from 'class-variance-authority';
+import { ChartConfig } from '../chart';
+import * as React from 'react';
+declare const categoryBarVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface CategoryBarSegment {
+    /** Key into `config` for this segment's label + color. */
+    key: string;
+    /** The segment's value — its width is this over the sum of all values. */
+    value: number;
+}
+/** The resolved segment passed to a custom `tooltipContent` renderer. */
+export interface CategoryBarTooltipContext extends CategoryBarSegment {
+    /** Resolved `config` label (falls back to the key); may be any `ReactNode`. */
+    label: React.ReactNode;
+    /** Share of the total as a rounded percentage (0–100). */
+    percent: number;
+    /**
+     * CSS color reference for the segment — the `var(--color-<key>)` bridge, which
+     * resolves the config entry's `color` or its per-theme `theme` value. Usable
+     * anywhere a CSS color is (e.g. a `style` background); not a literal value.
+     */
+    color: string;
+}
+export interface CategoryBarProps extends Omit<React.ComponentProps<'div'>, 'children'>, VariantProps<typeof categoryBarVariants> {
+    /** Ordered segments (left → right). Widths are proportional to `value`. */
+    data: ReadonlyArray<CategoryBarSegment>;
+    /** Maps each segment `key` to a `label` and `color` (an existing `--ui-*` token). */
+    config: ChartConfig;
+    /** Show the legend below the bar (color dot + label + value + %). */
+    showLegend?: boolean;
+    /** Show a hover tooltip per segment (dot + label + value + %). */
+    showTooltip?: boolean;
+    /**
+     * Custom tooltip content per segment — replaces the default (dot + label +
+     * `value · %`) inside the same card. Ignored when `showTooltip` is false.
+     */
+    tooltipContent?: (segment: CategoryBarTooltipContext) => React.ReactNode;
+    /** Format the numeric value (legend + tooltip). Defaults to `toLocaleString()`. */
+    valueFormatter?: (value: number) => string;
+    /** Render the tooltip for this segment index initially open (VR/testing). */
+    defaultOpenIndex?: number;
+    /**
+     * Accessible summary of the whole bar. Defaults to a `label value` list built
+     * from the data; pass a fuller sentence for screen readers if you have one.
+     */
+    'aria-label'?: string;
+}
+declare const CategoryBar: React.ForwardRefExoticComponent<Omit<CategoryBarProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { CategoryBar, categoryBarVariants };

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

@@ -0,0 +1 @@
+export { CategoryBar, categoryBarVariants, type CategoryBarProps, type CategoryBarSegment, type CategoryBarTooltipContext, } from './category-bar';

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

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

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

@@ -0,0 +1,111 @@
+import { AxisDomainItem } from 'recharts';
+import { ChartTooltipContentType } from './chart';
+/** A recharts-compatible tick formatter: `(value, index) => label`. */
+export type TickFormatter = (value: number | string, index?: number) => string;
+/**
+ * Props shared by every cartesian chart (Bar, Line, Area, Composed, Scatter,
+ * ConfidenceCone, Histogram) — chrome toggles, axis titles/units, tick
+ * formatting/visibility, and grid trim. All optional. `showLegend` and `xUnit`
+ * are deliberately *not* here: `showLegend` doesn't apply to `Histogram` and
+ * `xUnit` only to charts with a numeric X axis, so they stay per-component.
+ */
+export interface CartesianChartProps {
+    /** Render the CartesianGrid. Defaults to `true`. */
+    showGrid?: boolean;
+    /** Render the hover tooltip. Defaults to `true`. */
+    showTooltip?: boolean;
+    /**
+     * Replace the default tooltip. Pass a configured `ChartTooltipContent` (from
+     * this library) — e.g. with a `formatter` / `labelFormatter` — to customize it
+     * without composing recharts yourself. Ignored when `showTooltip` is false.
+     */
+    tooltipContent?: ChartTooltipContentType;
+    /** Title rendered beneath the X axis. */
+    xAxisLabel?: string;
+    /** Title rendered beside the Y axis (rotated). */
+    yAxisLabel?: string;
+    /**
+     * Unit suffix appended to the Y axis's tick values (recharts `unit`) — applies
+     * when the Y axis is the numeric one. `BarChart` with
+     * `orientation="horizontal"` puts the values on X instead; use `xUnit` there.
+     */
+    yUnit?: string;
+    /** Show the X axis (its ticks + title). Defaults to `true`. */
+    showXAxis?: boolean;
+    /** Show the Y axis (its ticks + title). Defaults to `true`. */
+    showYAxis?: boolean;
+    /** Format each X-axis tick value — e.g. `formatCompactNumber` or a `createTickFormatter(...)`. */
+    xTickFormatter?: TickFormatter;
+    /** Format each Y-axis tick value — e.g. `formatCompactNumber` or a `createTickFormatter(...)`. */
+    yTickFormatter?: TickFormatter;
+    /**
+     * Rotate the X-axis tick labels by this many degrees. A negative angle (e.g.
+     * `-45`) tilts them up toward the right; the tick anchor + axis height adjust
+     * to keep long labels readable.
+     */
+    xAxisAngle?: number;
+    /**
+     * X-axis tick density — a recharts placement strategy, or a fixed number of
+     * ticks to *skip* between two rendered ones (recharts `interval`: `0` shows
+     * every tick, `1` every other one, `2` every third, …).
+     */
+    xAxisInterval?: number | 'preserveStart' | 'preserveEnd' | 'preserveStartEnd' | 'equidistantPreserveStart';
+    /**
+     * Desired number of ticks on the value axis (recharts `tickCount`; a hint, not
+     * exact). Applies to whichever axis holds the values — Y for most charts, X for
+     * `BarChart` with `orientation="horizontal"`.
+     */
+    yAxisTickCount?: number;
+    /**
+     * Value-axis domain preset. Applies to whichever axis holds the values — Y for
+     * most charts, X for `BarChart` with `orientation="horizontal"`.
+     *
+     * - `auto` — fit the data at both ends; the axis need not include 0.
+     * - `zero` — anchor the axis at 0. This is also recharts' behavior when the
+     *   prop is omitted, so it's the explicit form of the default.
+     * - `dataMin-dataMax` — tight to the data, with no padding.
+     */
+    yAxisDomain?: 'auto' | 'dataMin-dataMax' | 'zero';
+    /** Draw grid lines dashed instead of solid. */
+    gridDashed?: boolean;
+    /** Show horizontal grid lines. Defaults to each chart's own default when unset. */
+    gridHorizontal?: boolean;
+    /** Show vertical grid lines. Defaults to each chart's own default when unset. */
+    gridVertical?: boolean;
+}
+/**
+ * Map a `yAxisDomain` preset to a recharts `domain`. Shared by all 7 cartesian
+ * charts, and applied to whichever axis holds the values (X for horizontal bars).
+ *
+ * `undefined` (no preset) is left to recharts, whose default is `[0, 'auto']` —
+ * i.e. already zero-anchored. That's why `auto` has to be spelled out as
+ * `['auto', 'auto']`: passing `undefined` for it would silently anchor at 0 and
+ * make the preset indistinguishable from `zero`.
+ */
+export declare function resolveAxisDomain(preset: 'auto' | 'dataMin-dataMax' | 'zero' | undefined): Readonly<[AxisDomainItem, AxisDomainItem]> | undefined;
+/**
+ * Compact thousands/millions: `1234 → "1.2K"`, `1_500_000 → "1.5M"`. Non-numeric
+ * values (including blank strings) pass through unchanged. Use for large-count
+ * axes (revenue, users, …).
+ *
+ * Formats in `en`. For another locale use
+ * `createTickFormatter({ notation: 'compact', maximumFractionDigits: 1 }, locale)`.
+ */
+export declare const formatCompactNumber: TickFormatter;
+/**
+ * Append a percent sign to an already-scaled value: `41.8 → "41.8%"`. (The value
+ * is treated as a percentage, not a 0–1 fraction.) Non-numeric values (including
+ * blank strings) pass through.
+ *
+ * Appends a bare `%`, which is not how every locale writes it. For locale-correct
+ * output on values that really are fractions, use
+ * `createTickFormatter({ style: 'percent' }, locale)`.
+ */
+export declare const formatPercent: TickFormatter;
+/**
+ * Build a tick formatter from `Intl.NumberFormat` options — the escape hatch for
+ * currency, fixed decimals, or a specific locale. E.g.
+ * `createTickFormatter({ style: 'currency', currency: 'USD', notation: 'compact' })`
+ * → `146500 → "$147K"`. Non-numeric values pass through unchanged.
+ */
+export declare function createTickFormatter(options: Intl.NumberFormatOptions, locale?: string): TickFormatter;

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

@@ -49,6 +49,8 @@ declare const ChartStyle: ({ id, config }: {
     config: ChartConfig;
 }) => import("react/jsx-runtime").JSX.Element | null;
 declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
+/** The `content` a caller passes to override the default tooltip (recharts' `Tooltip['content']`). */
+export type ChartTooltipContentType = React.ComponentProps<typeof ChartTooltip>['content'];
 declare function ChartTooltipContent({ active, payload, label, className, indicator, hideLabel, hideIndicator, labelFormatter, formatter, labelClassName, color, nameKey, labelKey, }: ChartTooltipContentProps): import("react/jsx-runtime").JSX.Element | null;
 declare const ChartLegend: React.MemoExoticComponent<(outsideProps: RechartsPrimitive.LegendProps) => React.ReactPortal | null>;
 declare function ChartLegendContent({ className, hideIcon, payload, verticalAlign, nameKey, }: ChartLegendContentProps): import("react/jsx-runtime").JSX.Element | null;

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

@@ -1,2 +1,4 @@
 export { ChartContainer, ChartTooltip, ChartTooltipContent, ChartLegend, ChartLegendContent, ChartStyle, } from './chart';
-export type { ChartConfig, ChartContainerProps, ChartTooltipContentProps, ChartLegendContentProps, } from './chart';
+export type { ChartConfig, ChartContainerProps, ChartTooltipContentProps, ChartLegendContentProps, ChartTooltipContentType, } from './chart';
+export { formatCompactNumber, formatPercent, createTickFormatter, resolveAxisDomain, } from './chart-format';
+export type { TickFormatter, CartesianChartProps } from './chart-format';

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

@@ -0,0 +1,11 @@
+import * as React from 'react';
+export interface ChartStateProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
+    /** Which placeholder to show. Drives the leading glyph and default label. */
+    state: 'loading' | 'empty' | 'error';
+    /** Overrides the default label for the current `state`. */
+    message?: string;
+    /** Trailing action (e.g. a "Try again" button) — shown for `error` only. */
+    action?: React.ReactNode;
+}
+declare const ChartState: React.ForwardRefExoticComponent<ChartStateProps & React.RefAttributes<HTMLDivElement>>;
+export { ChartState };

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

@@ -0,0 +1 @@
+export { ChartState, type ChartStateProps } from './chart-state';

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

@@ -0,0 +1,33 @@
+import { ChartConfig, CartesianChartProps } from '../chart';
+import * as React from 'react';
+export type ComposedSeriesType = 'bar' | 'line' | 'area';
+export interface ComposedSeries {
+    /** Column key to plot — must match a `config` entry; drives its `--color-<key>` paint. */
+    key: string;
+    /** How this series renders. */
+    type: ComposedSeriesType;
+}
+export interface ComposedChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, CartesianChartProps {
+    /** Row-per-category data. Each object holds `xKey` + one numeric field per series. */
+    data: ReadonlyArray<Record<string, string | number>>;
+    /**
+     * Per-series map of `label` / `color`, keyed by `series[].key` (imported from
+     * the shared `Chart` primitives). Turned into `--color-<key>` custom
+     * properties. Colors are caller-supplied — reference an existing semantic
+     * `--ui-*` token; there is no chart palette tier yet.
+     */
+    config: ChartConfig;
+    /** Series to plot, each `{ key, type }` — one bar/line/area per entry. Each key must exist in `config` and every data row. */
+    series: ComposedSeries[];
+    /** Category axis key (the shared dimension across rows, e.g. `"month"`). */
+    xKey: string;
+    /** Interpolation for the line and area series. */
+    curve?: 'linear' | 'monotone' | 'step';
+    /** Corner radius on the growing end of bar series. */
+    barRadius?: number;
+    /** Flat-fill opacity for area series. */
+    fillOpacity?: number;
+    showLegend?: boolean;
+}
+declare const ComposedChart: React.ForwardRefExoticComponent<Omit<ComposedChartProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ComposedChart };

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

@@ -0,0 +1 @@
+export { ComposedChart, type ComposedChartProps, type ComposedSeries, type ComposedSeriesType, } from './composed-chart';

package/dist/src/components/ui/confidence-cone/confidence-cone.d.ts

@@ -0,0 +1,62 @@
+import { ChartTooltip, ChartConfig, CartesianChartProps } from '../chart';
+import * as React from 'react';
+/**
+ * Drop the synthetic cone-band range series from a recharts tooltip/legend
+ * payload, keeping the real actual/forecast series (and their order). Applied to
+ * both the default tooltip and any caller-supplied `tooltipContent`, so the
+ * `__cone` band never surfaces regardless of which path renders.
+ */
+export declare function dropConeBand<T extends {
+    dataKey?: unknown;
+}>(payload: readonly T[] | undefined): T[] | undefined;
+/**
+ * Wrap a caller-supplied `tooltipContent` so the synthetic cone band is stripped
+ * from the payload before it renders, while preserving recharts' own mount
+ * semantics — a function is mounted via `createElement` (its own component
+ * identity + hook state), an element via `cloneElement`. This mirrors what the
+ * pass-through charts get by handing `content` straight to recharts, so a
+ * function-form tooltip keeps its state across re-renders here too. The returned
+ * component is a stable content type (memoize it on `tooltipContent`).
+ */
+type TooltipContentType = NonNullable<React.ComponentProps<typeof ChartTooltip>['content']>;
+type TooltipContentFn = Extract<TooltipContentType, (...args: never[]) => unknown>;
+type TooltipRenderProps = Parameters<TooltipContentFn>[0];
+export declare function createConeTooltip(tooltipContent: TooltipContentType): (props: TooltipRenderProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | React.FunctionComponentElement<import('recharts').TooltipContentProps<import('recharts').TooltipValueType, import('recharts/types/component/DefaultTooltipContent').NameType>>;
+export interface ConfidenceConeProps extends Omit<React.ComponentProps<'div'>, 'children'>, CartesianChartProps {
+    /**
+     * Row-per-point data — the shared x dimension plus the actual / forecast /
+     * bound fields. Rows are naturally sparse (a point has either an actual or a
+     * forecast + bounds), so missing fields are allowed. Avoid a field named
+     * `__cone` — it's reserved for the internal prediction-band series.
+     */
+    data: ReadonlyArray<Record<string, string | number | null | undefined>>;
+    /**
+     * Per-series map of `label` / `color` for the actual + forecast lines
+     * (imported from the shared `Chart` primitives). Colors are caller-supplied —
+     * reference an existing semantic `--ui-*` token; there is no chart palette tier
+     * yet. The cone band and the forecast line both reuse the actual series'
+     * color — actual and forecast differ by line style, not hue.
+     */
+    config: ChartConfig;
+    /** Category / time axis key (the shared dimension across rows). */
+    xKey: string;
+    /** Field for the known/actual values — drawn as a solid line with a filled area. */
+    actualKey: string;
+    /** Field for the projected values — drawn as a dashed line. */
+    forecastKey: string;
+    /** Field for the cone's lower bound. */
+    lowerKey: string;
+    /** Field for the cone's upper bound. */
+    upperKey: string;
+    /** Stroke width of the actual + forecast lines. */
+    strokeWidth?: number;
+    /**
+     * Set off the forecast period from the actuals with a dashed divider at the
+     * hand-off point (the first row with a forecast value) and a subtle shaded
+     * band over the forecast region.
+     */
+    showForecastRegion?: boolean;
+    showLegend?: boolean;
+}
+declare const ConfidenceCone: React.ForwardRefExoticComponent<Omit<ConfidenceConeProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ConfidenceCone };

package/dist/src/components/ui/confidence-cone/index.d.ts

@@ -0,0 +1 @@
+export { ConfidenceCone, type ConfidenceConeProps } from './confidence-cone';

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

@@ -2,17 +2,18 @@ import { Dialog as DialogPrimitive } from '@base-ui/react/dialog';
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const dialogContentVariants: (props?: ({
-    size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | null | undefined;
+    size?: "sm" | "large" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-declare const Dialog: typeof DialogPrimitive.Root;
+declare const DialogRoot: typeof DialogPrimitive.Root;
 declare const DialogTrigger: DialogPrimitive.Trigger;
 declare const DialogPortal: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').AlertDialogPortalProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const DialogClose: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').AlertDialogCloseProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AlertDialogBackdropProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export interface DialogContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Popup>, VariantProps<typeof dialogContentVariants> {
     /**
-     * Popup max-width. `sm` 512 · `xs` 464 · `md` 672 · `lg` 832 · `xl` 992 ·
-     * `2xl` 1136 (px). Defaults to `sm`.
+     * Popup max-width. `sm` (512px, default) is the Figma-defined size; `large`
+     * (832px) is a backward-compatibility size with no design token (see the
+     * `Large` story).
      */
     size?: VariantProps<typeof dialogContentVariants>['size'];
     /**
@@ -30,10 +31,105 @@ export interface DialogContentProps extends React.ComponentPropsWithoutRef<typeo
     keepMounted?: DialogPrimitive.Portal.Props['keepMounted'];
 }
 declare const DialogContent: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
-declare const DialogHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-declare const DialogFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-declare const DialogBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeaderRoot: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogFooterRoot: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogBodyRoot: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
 declare const DialogTitle: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AlertDialogTitleProps, "ref"> & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
 declare const DialogDescription: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AlertDialogDescriptionProps, "ref"> & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
-declare const DialogCloseButton: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AlertDialogCloseProps, "ref"> & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-export { Dialog, DialogPortal, DialogOverlay, DialogClose, DialogCloseButton, DialogTrigger, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogBody, DialogDescription, dialogContentVariants, };
+export interface DialogCloseButtonProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Close> {
+    /** Accessible name for screen readers. Defaults to `'Close'`. */
+    closeLabel?: string;
+}
+declare const DialogCloseButton: React.ForwardRefExoticComponent<DialogCloseButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export type DialogVariant = 'default' | 'rename' | 'save changes' | 'reset password' | 'discard changes' | 'accept' | 'read-only' | 'wide';
+type DialogRootProps = React.ComponentPropsWithoutRef<typeof DialogRoot>;
+export interface DialogProps extends Omit<DialogRootProps, 'children'> {
+    /**
+     * Selects the canned title / body / footer preset. Defaults to `'default'`.
+     * `'wide'` is a legacy escape hatch (no canned preset) kept for backward
+     * compatibility — pair it with `size="large"` and the `footer` prop.
+     */
+    variant?: DialogVariant;
+    /**
+     * Show a spinner overlay across the body + footer, and make both `inert`
+     * (unfocusable, unclickable, hidden from assistive tech) so a keyboard user
+     * can't activate the visually obscured footer buttons while busy.
+     */
+    hasLoading?: boolean;
+    /**
+     * Overrides the loading overlay's accessible label. Defaults to `Loading`'s
+     * own default (`'Data is loading…'`). Ignored when `hasLoading` is `false`.
+     */
+    loadingLabel?: string;
+    /**
+     * Show the header (title + close button). Defaults to `true`. When `false`,
+     * the title is still rendered off-screen so the dialog keeps an accessible
+     * name — only the visible bar and close button are omitted. Beyond the
+     * strict Figma contract (all seven `DialogDefault` variants always show the
+     * header); a ui-react-only extension, like `wide`/`size="large"`.
+     */
+    hasHeader?: boolean;
+    /**
+     * Show the footer (action buttons). Defaults to `true`. Beyond the strict
+     * Figma contract (all seven `DialogDefault` variants always show the
+     * footer); a ui-react-only extension, like `wide`/`size="large"`. When
+     * `false`, `footer` (and the canned footer it would otherwise replace) is
+     * not rendered either.
+     */
+    hasFooter?: boolean;
+    /** Overrides the variant's default body content. */
+    children?: React.ReactNode;
+    /** Overrides the variant's default title. */
+    title?: string;
+    /**
+     * The real name of the object being acted on (e.g. a file or resource
+     * name). Interpolated into the `rename`/`discard changes`/`accept`
+     * variants' canned title/body in place of the generic placeholder text;
+     * ignored by variants that don't reference an object name.
+     */
+    objectName?: string;
+    /**
+     * Overrides the accessible name of the `rename` variant's text field
+     * (default `'Object name'`). Ignored by every other variant.
+     */
+    objectNameLabel?: string;
+    /**
+     * Overrides the variant's default secondary (dismiss) button label. Passing
+     * this for a variant with no secondary button by default (e.g. `read-only`)
+     * also makes the button appear. Ignored when `footer` is provided.
+     */
+    secondaryLabel?: string;
+    /** Overrides the variant's default primary button label. Ignored when `footer` is provided. */
+    primaryLabel?: string;
+    /**
+     * Fires when the primary footer button is clicked. The dialog does not
+     * close automatically afterwards — pair this with `open`/`onOpenChange` to
+     * close it once the action completes. Ignored when `footer` is provided
+     * (wire behavior onto your own buttons there instead).
+     */
+    onPrimaryAction?: () => void;
+    /**
+     * Replaces the footer's action content entirely with free-form buttons —
+     * the escape hatch the `wide` variant is meant to be paired with, for
+     * legacy call sites that don't fit one of the seven canned presets. Ignored
+     * (along with the canned footer) when `hasFooter` is `false`.
+     */
+    footer?: React.ReactNode;
+    /** Overrides the close button's accessible name. Defaults to `'Close'`. */
+    closeLabel?: string;
+    /**
+     * Popup max-width (forwarded to `DialogContent`). Defaults to `'sm'`, or to
+     * `'large'` when `variant` is `'wide'`.
+     */
+    size?: DialogContentProps['size'];
+    /** Render inside a portal (forwarded to `DialogContent`). Defaults to `true`. */
+    portal?: boolean;
+    /** Portal container (forwarded to `DialogContent`). */
+    portalContainer?: DialogContentProps['portalContainer'];
+    /** Keep the content mounted while closed (forwarded to `DialogContent`). */
+    keepMounted?: DialogContentProps['keepMounted'];
+    /** Extra classes merged onto the popup container. */
+    className?: string;
+}
+declare const Dialog: React.ForwardRefExoticComponent<DialogProps & React.RefAttributes<HTMLDivElement>>;
+export { DialogRoot, DialogPortal, DialogOverlay, DialogClose, DialogCloseButton, DialogTrigger, DialogContent, DialogHeaderRoot, DialogFooterRoot, DialogTitle, DialogBodyRoot, DialogDescription, dialogContentVariants, Dialog, };