@acronis-platform/ui-react 0.57.1 → 0.58.0

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

@@ -0,0 +1,55 @@
+import { ChartTooltip, ChartConfig } from '../chart';
+import * as React from 'react';
+export interface HistogramBin {
+    /** Lower bound of the bin (inclusive). */
+    x0: number;
+    /** Upper bound of the bin (exclusive, except the last bin which is inclusive). */
+    x1: number;
+    /** Human-readable range label, e.g. `"0–10"`. */
+    label: string;
+    /** How many samples fell in the bin. */
+    count: number;
+}
+/**
+ * Split `values` into `binCount` equal-width bins and count the samples in each.
+ * The range is `domain` if given, else the data's [min, max]; values outside the
+ * domain are dropped, and the max value lands in the last (inclusive) bin.
+ * Returns [] when there's nothing to bin. Exported for unit tests; not part of
+ * the package's public API.
+ */
+export declare function computeHistogramBins(values: ReadonlyArray<number>, binCount: number, domain?: [number, number]): HistogramBin[];
+export interface HistogramProps extends Omit<React.ComponentProps<'div'>, 'children'> {
+    /** Raw continuous samples to bin (non-finite values are ignored). */
+    values: ReadonlyArray<number>;
+    /**
+     * Single-series map of `label` / `color`, keyed by `dataKey` (imported from
+     * the shared `Chart` primitives). Color is caller-supplied — reference an
+     * existing semantic `--ui-*` token; there is no chart palette tier yet.
+     */
+    config: ChartConfig;
+    /** `config` key that colors + labels the frequency bars. */
+    dataKey?: string;
+    /** Number of equal-width bins. */
+    binCount?: number;
+    /** Fix the binning range instead of deriving it from the data's min/max. */
+    domain?: [number, number];
+    /** Title rendered beneath the horizontal (X) axis. */
+    xAxisLabel?: string;
+    /** Title rendered beside the vertical (Y) axis (rotated). */
+    yAxisLabel?: string;
+    /** Unit suffix appended to Y-axis tick values (recharts `unit`; the X axis is the bin label). */
+    yUnit?: string;
+    /** Corner radius on the top of each bar. */
+    barRadius?: number;
+    showGrid?: boolean;
+    showTooltip?: boolean;
+    /**
+     * Replace the default tooltip. Pass a configured `ChartTooltipContent`
+     * (imported from this library) — e.g. with a `formatter` / `labelFormatter` —
+     * to customize the tooltip without composing recharts yourself. Ignored when
+     * `showTooltip` is false.
+     */
+    tooltipContent?: React.ComponentProps<typeof ChartTooltip>['content'];
+}
+declare const Histogram: React.ForwardRefExoticComponent<Omit<HistogramProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Histogram };

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

@@ -0,0 +1 @@
+export { Histogram, type HistogramProps, type HistogramBin } from './histogram';

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

@@ -0,0 +1 @@
+export { InputOTP, type InputOTPProps } from './input-otp';

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

@@ -0,0 +1,23 @@
+import * as React from 'react';
+export interface InputOTPProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'onChange' | 'defaultValue' | 'children'> {
+    /** Number of single-character slots. */
+    length?: number;
+    /** Controlled value (the digits entered so far, left to right). */
+    value?: string;
+    /** Initial value for uncontrolled usage. */
+    defaultValue?: string;
+    /** Fires with the full value on every change. */
+    onChange?: (value: string) => void;
+    /** Fires once, the moment the value reaches `length` characters. */
+    onComplete?: (value: string) => void;
+    /** Disables every slot. */
+    disabled?: boolean;
+    /** Switches every slot to the error treatment. */
+    error?: boolean;
+    /** Focuses the first slot on mount. */
+    autoFocus?: boolean;
+    /** Builds the accessible name for a slot from its 1-based index and the total length. */
+    slotAriaLabel?: (index: number, length: number) => string;
+}
+declare const InputOTP: React.ForwardRefExoticComponent<InputOTPProps & React.RefAttributes<HTMLDivElement>>;
+export { InputOTP };

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

@@ -0,0 +1 @@
+export { InputPassword, type InputPasswordProps } from './input-password';

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

@@ -0,0 +1,21 @@
+import * as React from 'react';
+export interface InputPasswordProps extends Omit<React.ComponentPropsWithoutRef<'input'>, 'children' | 'type'> {
+    /** Field label, rendered above the input. */
+    label?: React.ReactNode;
+    /** Marks the field required — appends a `*` after the label. */
+    required?: boolean;
+    /** Helper text below the input. Hidden while `error` is set. */
+    description?: React.ReactNode;
+    /**
+     * Error message below the input. Its presence switches the field to the error
+     * treatment (red box border + red message).
+     */
+    error?: React.ReactNode;
+    /** Accessible label for the toggle button while the password is hidden. */
+    showPasswordLabel?: string;
+    /** Accessible label for the toggle button while the password is shown. */
+    hidePasswordLabel?: string;
+}
+export declare function getInputPasswordBoxClassName(hasError: boolean, disabled?: boolean): string;
+declare const InputPassword: React.ForwardRefExoticComponent<InputPasswordProps & React.RefAttributes<HTMLInputElement>>;
+export { InputPassword };

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

@@ -0,0 +1 @@
+export { LineChart, lineChartVariants, type LineChartProps } from './line-chart';

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

@@ -0,0 +1,83 @@
+import { VariantProps } from 'class-variance-authority';
+import { ChartTooltip, ChartConfig } from '../chart';
+import * as React from 'react';
+declare const lineChartVariants: (props?: ({
+    curve?: "step" | "linear" | "monotone" | null | undefined;
+    lineStyle?: "dashed" | "solid" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+/**
+ * Drop the synthetic delta-band range series from a recharts tooltip/legend
+ * payload, keeping the real series (and their order). recharts already excludes
+ * the band via `legendType`/`tooltipType="none"`, so this is a second, explicit
+ * guard — hence it's unit-tested rather than relying on that behavior.
+ */
+export declare function dropBandSeries<T extends {
+    dataKey?: unknown;
+}>(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];
+/**
+ * Wrap a caller-supplied `tooltipContent` so the synthetic delta bands are
+ * 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`).
+ */
+export declare function createBandStrippedTooltip(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 LineChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, VariantProps<typeof lineChartVariants> {
+    /** Row-per-point data. Each object holds the category key + one numeric field per series (`null` breaks the line 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 `<Line>` per key. Each must exist in `config` and in every data row. */
+    dataKeys: string[];
+    /**
+     * Subset of `dataKeys` to render as comparison/trend overlays (e.g. a
+     * previous quarter or year) — dashed, dimmed, and dot-less, so they read as
+     * secondary to the current-period lines. Keeps each series' own `config` color.
+     */
+    comparisonKeys?: string[];
+    /**
+     * Pairs of `[currentKey, comparisonKey]` to shade a delta band between — a
+     * dimmed area filling the gap between the two series at each point,
+     * visualizing the QoQ/YoY difference. Tinted with the first key's `config`
+     * color. Rows where either value isn't numeric are left un-banded.
+     *
+     * Each pair mints an internal `__band_<n>` field (kept out of the tooltip and
+     * legend), so avoid data/`config` keys with that reserved prefix.
+     */
+    deltaBands?: Array<[string, string]>;
+    /** Category axis key (the shared dimension across rows, e.g. `"month"`). */
+    xKey: string;
+    /** Title rendered beneath the horizontal (X) axis. */
+    xAxisLabel?: string;
+    /** Title rendered beside the vertical (Y) axis (rotated). */
+    yAxisLabel?: string;
+    /** Unit suffix appended to Y-axis tick values (recharts `unit`; the X axis is categorical). */
+    yUnit?: string;
+    /** Stroke width of each line. */
+    strokeWidth?: number;
+    /** Render a dot at each data point. */
+    showDots?: boolean;
+    /** Bridge `null` gaps in the data instead of breaking the line. */
+    connectNulls?: boolean;
+    showGrid?: boolean;
+    showTooltip?: boolean;
+    showLegend?: boolean;
+    /**
+     * Replace the default tooltip. Pass a configured `ChartTooltipContent`
+     * (imported from this library) — e.g. with a `formatter` / `labelFormatter` /
+     * `indicator` — to customize formatting, per-series rows, or extra fields
+     * without composing recharts yourself. Ignored when `showTooltip` is false.
+     */
+    tooltipContent?: React.ComponentProps<typeof ChartTooltip>['content'];
+}
+declare const LineChart: React.ForwardRefExoticComponent<Omit<LineChartProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { LineChart, lineChartVariants };

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

@@ -0,0 +1 @@
+export { Loading, loadingVariants, type LoadingProps } from './loading';

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

@@ -0,0 +1,13 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const loadingVariants: (props?: ({
+    variant?: "inline" | "onSurfacePrimary" | "onSurfaceSecondary" | "onScreen" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface LoadingProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof loadingVariants> {
+    /** Whether the label is rendered. When `false`, `label` is still exposed to assistive tech via `aria-label`. */
+    hasLabel?: boolean;
+    /** The loading message. */
+    label?: string;
+}
+declare const Loading: React.ForwardRefExoticComponent<LoadingProps & React.RefAttributes<HTMLDivElement>>;
+export { Loading, loadingVariants };

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

@@ -0,0 +1 @@
+export { Meter, type MeterProps } from './meter';

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

@@ -0,0 +1,25 @@
+import { Meter as MeterPrimitive } from '@base-ui/react/meter';
+import * as React from 'react';
+export interface MeterProps extends Omit<React.ComponentPropsWithoutRef<typeof MeterPrimitive.Root>, 'value' | 'color'> {
+    /** Row label shown on the left. */
+    label: string;
+    /** The value this meter represents. */
+    value: number;
+    /** Upper bound of the range — the whole the value is a share of. */
+    max?: number;
+    /** Fill color for the bar — an existing semantic `--ui-*` token (or any CSS color). */
+    color: string;
+    /** Format the numeric value (label + tooltip). Defaults to `toLocaleString()`. */
+    valueFormatter?: (value: number) => string;
+    /** Show the hover tooltip (`label · value of max · %`). */
+    showTooltip?: boolean;
+    /**
+     * Custom tooltip content — replaces the default (dot + label + `value of max
+     * · %`) inside the same chart-style card. Ignored when `showTooltip` is false.
+     */
+    tooltip?: React.ReactNode;
+    /** Render with the tooltip initially open (Base UI `defaultOpen`). */
+    defaultOpen?: boolean;
+}
+declare const Meter: React.ForwardRefExoticComponent<MeterProps & React.RefAttributes<HTMLDivElement>>;
+export { Meter };

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

@@ -0,0 +1 @@
+export { Metric, type MetricProps } from './metric';

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

@@ -0,0 +1,37 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const metricVariants: (props?: ({
+    size?: "small" | "medium" | "large" | null | undefined;
+    status?: "info" | "success" | "warning" | "critical" | "neutral" | "danger" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface MetricProps extends React.ComponentProps<'div'>, VariantProps<typeof metricVariants> {
+    /** What the value measures — e.g. "Gross margin". Rendered as an uppercase note heading. */
+    label: React.ReactNode;
+    /**
+     * The primary value, already formatted (`73`, `"94%"`, `"$72K"`, `"2.8"`).
+     * The kit does not format currency, units, or decimals.
+     */
+    value: React.ReactNode;
+    /** Unit shown next to the value at a smaller, muted size — e.g. `"%"`, `"hours"`. */
+    unit?: React.ReactNode;
+    /** A top-right caption aligned with the label — e.g. a timeframe `Tag` ("Last 30 days"). */
+    caption?: React.ReactNode;
+    /** A trend slot on the right of the value — typically a `TrendIndicator`. */
+    trend?: React.ReactNode;
+    /** Secondary line below the value — e.g. "Target: 99%". */
+    supportingText?: React.ReactNode;
+    /** A small badge / metadata slot beside the value — e.g. a `Tag`. */
+    badge?: React.ReactNode;
+    /** Icon rendered in a status-tinted badge before the value. */
+    icon?: React.ReactNode;
+    /** Contextual hint on an info affordance next to the label (Base UI Tooltip). */
+    tooltip?: React.ReactNode;
+    /** Accessible name for the info affordance that reveals `tooltip`. */
+    tooltipLabel?: string;
+    /** Show a skeleton in place of the value, preserving its space. */
+    loading?: boolean;
+    /** Card body below the header — e.g. a chart, a Separator, an insight line. */
+    children?: React.ReactNode;
+}
+declare const Metric: React.ForwardRefExoticComponent<Omit<MetricProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Metric };

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

@@ -0,0 +1 @@
+export { PieChart, pieChartVariants, type PieChartProps, type PieChartCenterLabel, } from './pie-chart';

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

@@ -0,0 +1,54 @@
+import { VariantProps } from 'class-variance-authority';
+import { ChartTooltip, ChartConfig } from '../chart';
+import * as React from 'react';
+declare const pieChartVariants: (props?: ({
+    shape?: "pie" | "donut" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface PieChartCenterLabel {
+    /** Headline metric rendered large in the donut hole (e.g. a total). */
+    value?: string | number;
+    /** Caption rendered under the value. */
+    label?: string | number;
+}
+export interface PieChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, VariantProps<typeof pieChartVariants> {
+    /** Row-per-slice data. Each object holds the slice's `nameKey` label + its `dataKey` numeric value. */
+    data: ReadonlyArray<Record<string, string | number>>;
+    /**
+     * Per-slice map of `label` / `color`, keyed by the slice's `nameKey` value
+     * (imported from the shared `Chart` primitives). Turned into `--color-<name>`
+     * custom properties. Colors are caller-supplied — reference an existing
+     * semantic `--ui-*` token; there is no chart palette tier yet.
+     */
+    config: ChartConfig;
+    /** Numeric field that sizes each slice. */
+    dataKey: string;
+    /**
+     * Label field that names each slice (drives the legend, tooltip, and
+     * `--color-<name>` lookup). Values should be unique per chart — rows sharing a
+     * name share one `config`/color entry.
+     */
+    nameKey: string;
+    /** Inner radius of the arc when `shape="donut"` (ignored for `shape="pie"`). */
+    innerRadius?: number;
+    /**
+     * Custom content for the donut hole — a headline `value` and/or a `label`
+     * caption, stacked and centered. Rendered only for `shape="donut"` (a filled
+     * pie has no hole).
+     */
+    centerLabel?: PieChartCenterLabel;
+    /** Outer radius of the arc. Omit to use recharts' responsive default. */
+    outerRadius?: number;
+    /** Gap between slices, in degrees. */
+    paddingAngle?: number;
+    showTooltip?: boolean;
+    showLegend?: boolean;
+    /**
+     * Replace the default tooltip. Pass a configured `ChartTooltipContent`
+     * (imported from this library) — e.g. with a `formatter` / `labelFormatter` —
+     * to customize formatting, per-slice rows, or extra fields without composing
+     * recharts yourself. Ignored when `showTooltip` is false.
+     */
+    tooltipContent?: React.ComponentProps<typeof ChartTooltip>['content'];
+}
+declare const PieChart: React.ForwardRefExoticComponent<Omit<PieChartProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { PieChart, pieChartVariants };

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

@@ -1 +1 @@
-export { Popover, PopoverTrigger, PopoverPortal, PopoverContent, type PopoverContentProps, } from './popover';
+export { Popover, PopoverTrigger, PopoverPortal, PopoverContent, type PopoverContentProps, PopoverBody, PopoverFooter, } from './popover';

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

@@ -24,4 +24,16 @@ export interface PopoverContentProps extends React.ComponentPropsWithoutRef<type
     keepMounted?: PopoverPrimitive.Portal.Props['keepMounted'];
 }
 declare const PopoverContent: React.ForwardRefExoticComponent<PopoverContentProps & React.RefAttributes<HTMLDivElement>>;
-export { Popover, PopoverTrigger, PopoverPortal, PopoverContent };
+/**
+ * Vertical-rhythm wrapper for a `PopoverContent`'s main content — the `Body`
+ * slot in the Figma node. Themed from `--ui-popover-body-*` (gap, padding-y);
+ * horizontal inset is a plain utility since the design has no dedicated
+ * component token for it.
+ */
+declare const PopoverBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Default action-row footer — the `FooterDefault` (`variant=default`) recipe
+ * from the Figma node. Themed from the shared `--ui-footer-*` tier.
+ */
+declare const PopoverFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Popover, PopoverTrigger, PopoverPortal, PopoverContent, PopoverBody, PopoverFooter, };

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

@@ -0,0 +1 @@
+export { RadarChart, radarChartVariants, type RadarChartProps } from './radar-chart';

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

@@ -0,0 +1,40 @@
+import { VariantProps } from 'class-variance-authority';
+import { ChartTooltip, ChartConfig } from '../chart';
+import * as React from 'react';
+declare const radarChartVariants: (props?: ({
+    gridType?: "circle" | "polygon" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface RadarChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, VariantProps<typeof radarChartVariants> {
+    /** Row-per-axis data. Each object holds the `angleKey` label + one numeric field per series. */
+    data: ReadonlyArray<Record<string, string | number>>;
+    /**
+     * Per-series map of `label` / `color` (imported from the shared `Chart`
+     * primitives). Turned into `--color-<key>` custom properties. Series colors
+     * are caller-supplied — reference an existing semantic `--ui-*` token; there is
+     * no chart palette tier yet.
+     */
+    config: ChartConfig;
+    /** Series to plot — one `<Radar>` per key. Each must exist in `config` and in every data row. */
+    dataKeys: string[];
+    /** The categorical axis key placed around the web (e.g. `"subject"`). */
+    angleKey: string;
+    /** Fill opacity of each radar area. */
+    fillOpacity?: number;
+    /** Stroke width of each radar outline. */
+    strokeWidth?: number;
+    /** Render a dot at each axis point. */
+    showDots?: boolean;
+    /** Render the polar grid (the web). */
+    showGrid?: boolean;
+    showTooltip?: boolean;
+    showLegend?: boolean;
+    /**
+     * Replace the default tooltip. Pass a configured `ChartTooltipContent`
+     * (imported from this library) — e.g. with a `formatter` / `labelFormatter` /
+     * `indicator` — to customize formatting, per-series rows, or extra fields
+     * without composing recharts yourself. Ignored when `showTooltip` is false.
+     */
+    tooltipContent?: React.ComponentProps<typeof ChartTooltip>['content'];
+}
+declare const RadarChart: React.ForwardRefExoticComponent<Omit<RadarChartProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { RadarChart, radarChartVariants };

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

@@ -0,0 +1 @@
+export { RadialBarChart, type RadialBarChartProps, } from './radial-bar-chart';

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

@@ -0,0 +1,45 @@
+import { ChartTooltip, ChartConfig } from '../chart';
+import * as React from 'react';
+export interface RadialBarChartProps extends Omit<React.ComponentProps<'div'>, 'children'> {
+    /** Row-per-arc data. Each object holds the arc's `nameKey` label + its `dataKey` numeric value. */
+    data: ReadonlyArray<Record<string, string | number>>;
+    /**
+     * Per-arc map of `label` / `color`, keyed by the arc's `nameKey` value
+     * (imported from the shared `Chart` primitives). Turned into `--color-<name>`
+     * custom properties. Colors are caller-supplied — reference an existing
+     * semantic `--ui-*` token; there is no chart palette tier yet.
+     */
+    config: ChartConfig;
+    /** Numeric field that sizes each arc. */
+    dataKey: string;
+    /**
+     * Label field that names each arc (drives the legend, tooltip, and
+     * `--color-<name>` lookup). Values should be unique per chart (arcs sharing a
+     * name share one `config`/color entry) and CSS-safe — they become part of a
+     * custom-property name.
+     */
+    nameKey: string;
+    /** Inner radius of the innermost arc. */
+    innerRadius?: number;
+    /** Outer radius of the outermost arc. */
+    outerRadius?: number;
+    /** Angle (degrees) the arcs sweep from. */
+    startAngle?: number;
+    /** Angle (degrees) the arcs sweep to (default is a full clockwise circle). */
+    endAngle?: number;
+    /** Corner radius on each arc's ends. */
+    cornerRadius?: number;
+    /** Render a muted background track behind each arc. */
+    showBackground?: boolean;
+    showTooltip?: boolean;
+    showLegend?: boolean;
+    /**
+     * Replace the default tooltip. Pass a configured `ChartTooltipContent`
+     * (imported from this library) — e.g. with a `formatter` / `labelFormatter` —
+     * to customize formatting, per-arc rows, or extra fields without composing
+     * recharts yourself. Ignored when `showTooltip` is false.
+     */
+    tooltipContent?: React.ComponentProps<typeof ChartTooltip>['content'];
+}
+declare const RadialBarChart: React.ForwardRefExoticComponent<Omit<RadialBarChartProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { RadialBarChart };

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

@@ -0,0 +1 @@
+export { ScatterChart, type ScatterChartProps, type ScatterSeries, type ScatterMarkerShape, } from './scatter-chart';

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

@@ -0,0 +1,50 @@
+import { ChartTooltip, ChartConfig } from '../chart';
+import * as React from 'react';
+export type ScatterMarkerShape = 'circle' | 'cross' | 'diamond' | 'square' | 'star' | 'triangle' | 'wye';
+export interface ScatterSeries {
+    /** Series key — must match a `config` entry; drives its `--color-<key>` fill and legend label. */
+    key: string;
+    /** This series' points — each row holds at least `xKey` and `yKey` (and `zKey` when used). */
+    data: ReadonlyArray<Record<string, number>>;
+}
+export interface ScatterChartProps extends Omit<React.ComponentProps<'div'>, 'children'> {
+    /** One `<Scatter>` per entry — each with its own point array. Use a single entry for an ungrouped scatter. */
+    series: ScatterSeries[];
+    /**
+     * 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;
+    /** Numeric field for the horizontal axis. */
+    xKey: string;
+    /** Numeric field for the vertical axis. */
+    yKey: string;
+    /** Title rendered beneath the horizontal (X) axis. */
+    xAxisLabel?: string;
+    /** Title rendered beside the vertical (Y) axis (rotated). */
+    yAxisLabel?: string;
+    /** Unit suffix appended to X-axis tick values (recharts `unit`). */
+    xUnit?: string;
+    /** Unit suffix appended to Y-axis tick values (recharts `unit`). */
+    yUnit?: string;
+    /** Optional numeric field mapped to point size (a bubble chart), via recharts `ZAxis`. */
+    zKey?: string;
+    /** Point-size range `[min, max]` the `zKey` maps into. Ignored when `zKey` is unset (points use recharts' default size). */
+    zRange?: [number, number];
+    /** Marker shape for every point. */
+    shape?: ScatterMarkerShape;
+    showGrid?: boolean;
+    showTooltip?: boolean;
+    showLegend?: boolean;
+    /**
+     * Replace the default tooltip. Pass a configured `ChartTooltipContent`
+     * (imported from this library) — e.g. with a `formatter` / `labelFormatter` /
+     * `indicator` — to customize formatting, per-series rows, or extra fields
+     * without composing recharts yourself. Ignored when `showTooltip` is false.
+     */
+    tooltipContent?: React.ComponentProps<typeof ChartTooltip>['content'];
+}
+declare const ScatterChart: React.ForwardRefExoticComponent<Omit<ScatterChartProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ScatterChart };

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

@@ -2,7 +2,7 @@ import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const stackVariants: (props?: ({
     direction?: "horizontal" | "vertical" | null | undefined;
-    gap?: "none" | "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    gap?: "none" | "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
     align?: "center" | "end" | "start" | "stretch" | null | undefined;
     justify?: "center" | "end" | "start" | "between" | null | undefined;
     wrap?: boolean | null | undefined;

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

@@ -0,0 +1 @@
+export { Timeline, TimelineItem, type TimelineProps, type TimelineItemProps, type TimelineStatus, } from './timeline';

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

@@ -0,0 +1,41 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const timelineVariants: (props?: ({
+    size?: "small" | "medium" | null | undefined;
+    density?: "compact" | "default" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface TimelineProps extends React.ComponentProps<'ol'>, VariantProps<typeof timelineVariants> {
+    /**
+     * `Timeline.Item`s — pass them as direct children (the connector auto-hides on
+     * the last one). Grouping/headings aren't supported as intervening children.
+     */
+    children?: React.ReactNode;
+}
+export type TimelineStatus = 'neutral' | 'info' | 'success' | 'warning' | 'danger' | 'critical';
+export interface TimelineItemProps extends Omit<React.ComponentProps<'li'>, 'title'> {
+    /** Event time — pass a `<time dateTime>` for an accessible, machine-readable stamp. */
+    timestamp?: React.ReactNode;
+    /** Event title (the primary line). */
+    title: React.ReactNode;
+    /** Optional secondary description. */
+    description?: React.ReactNode;
+    /** Semantic status — tints the marker (a subtle cue, never large blocks of text). */
+    status?: TimelineStatus;
+    /** Icon shown in a status-tinted marker badge instead of the plain dot. */
+    icon?: React.ReactNode;
+    /** Metadata slot under the description — e.g. `Tag`s. */
+    metadata?: React.ReactNode;
+    /** Actions slot — e.g. a `Link` or `ButtonMenu`. */
+    actions?: React.ReactNode;
+    /** Emphasize this item as the current one (a ringed marker). */
+    current?: boolean;
+    /** Dim a non-applicable / inactive item. */
+    disabled?: boolean;
+    /** Expandable detail composed by the caller — e.g. an `Accordion`. */
+    children?: React.ReactNode;
+}
+declare const TimelineItem: React.ForwardRefExoticComponent<Omit<TimelineItemProps, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const Timeline: React.ForwardRefExoticComponent<Omit<TimelineProps, "ref"> & React.RefAttributes<HTMLOListElement>> & {
+    Item: React.ForwardRefExoticComponent<Omit<TimelineItemProps, "ref"> & React.RefAttributes<HTMLLIElement>>;
+};
+export { Timeline, TimelineItem };

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

@@ -0,0 +1 @@
+export { Treemap, type TreemapProps } from './treemap';

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

@@ -0,0 +1,44 @@
+import { ChartTooltip, ChartConfig } from '../chart';
+import * as React from 'react';
+interface TreemapCellProps {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    name?: string;
+    showLabels?: boolean;
+}
+export declare function TreemapCell({ x, y, width, height, name, showLabels, }: TreemapCellProps): import("react/jsx-runtime").JSX.Element;
+export interface TreemapProps extends Omit<React.ComponentProps<'div'>, 'children'> {
+    /** Row-per-leaf data. Each object holds the leaf's `nameKey` label + its `dataKey` numeric size. */
+    data: ReadonlyArray<Record<string, string | number>>;
+    /**
+     * Per-leaf map of `label` / `color`, keyed by the leaf's `nameKey` value
+     * (imported from the shared `Chart` primitives). Turned into `--color-<name>`
+     * custom properties. Colors are caller-supplied — reference an existing
+     * semantic `--ui-*` token; there is no chart palette tier yet.
+     */
+    config: ChartConfig;
+    /** Numeric field that sizes each leaf's rectangle. */
+    dataKey: string;
+    /**
+     * Label field that names each leaf (drives the on-cell label, tooltip, and
+     * `--color-<name>` lookup). Values should be unique and CSS-safe (they become
+     * part of a custom-property name).
+     */
+    nameKey: string;
+    /** Width-to-height ratio the tiling targets. */
+    aspectRatio?: number;
+    /** Render each leaf's name inside its cell (when it fits). */
+    showLabels?: boolean;
+    showTooltip?: boolean;
+    /**
+     * Replace the default tooltip. Pass a configured `ChartTooltipContent`
+     * (imported from this library) — e.g. with a `formatter` / `labelFormatter` —
+     * to customize formatting, per-cell rows, or extra fields without composing
+     * recharts yourself. Ignored when `showTooltip` is false.
+     */
+    tooltipContent?: React.ComponentProps<typeof ChartTooltip>['content'];
+}
+declare const Treemap: React.ForwardRefExoticComponent<Omit<TreemapProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Treemap };

package/dist/src/components/ui/trend-indicator/index.d.ts

@@ -0,0 +1 @@
+export { TrendIndicator, trendIndicatorVariants, type TrendIndicatorProps, } from './trend-indicator';