@acronis-platform/ui-react 0.60.0 → 0.62.0

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

@@ -1,14 +1,23 @@
-import { ChartTooltip, ChartConfig, CartesianChartProps } from '../chart';
+import { ChartTooltip, ChartConfig, CartesianChartProps, ChartAnimationProps } from '../chart';
 import * as React from 'react';
 /**
- * Drop the synthetic cone-band range series from a recharts tooltip/legend
+ * Drop every 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.
+ * both the default tooltip and any caller-supplied `tooltipContent`, so no band
+ * surfaces regardless of which path renders or how many series are plotted.
  */
 export declare function dropConeBand<T extends {
     dataKey?: unknown;
 }>(payload: readonly T[] | undefined): T[] | undefined;
+/**
+ * Reduce a legend payload to the metrics the chart plots — one entry per series.
+ * A series' actual, forecast and cone are three recharts series painting a
+ * single metric in a single hue, so the legend names each metric once, with its
+ * actual series' swatch, instead of listing line styles as separate series.
+ */
+export declare function keepMetricSeries<T extends {
+    dataKey?: unknown;
+}>(payload: readonly T[] | undefined, actualKeys: readonly string[]): 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
@@ -22,34 +31,124 @@ type TooltipContentType = NonNullable<React.ComponentProps<typeof ChartTooltip>[
 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 {
+/**
+ * One plotted metric: its actual / forecast columns and, optionally, the two
+ * bound columns that shade its cone. Omit `lowerKey`/`upperKey` for a band-less
+ * metric — a solid line handing off to a bare dashed projection.
+ */
+export interface ConfidenceConeSeries {
+    /** 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. Omit (with `upperKey`) for no cone. */
+    lowerKey?: string;
+    /** Field for the cone's upper bound. Omit (with `lowerKey`) for no cone. */
+    upperKey?: string;
+}
+/**
+ * The x values of the projected period — every row carrying a forecast value for
+ * at least one series, in data order. The first is the hand-off point (where the
+ * shaded region and divider start); the whole set drives the forecast tick
+ * styling, matched by value so tick `interval` can't skew it the way a tick
+ * index would. Exported for unit tests; not part of the package's public API.
+ */
+export declare function forecastPeriodX(data: ReadonlyArray<Record<string, string | number | null | undefined>>, series: readonly ConfidenceConeSeries[], xKey: string): Array<string | number | null | undefined>;
+/**
+ * Build the X-axis tick renderer that sets the projected columns apart: italic,
+ * in the metric's hue. Styled inline rather than through the `fill` attribute
+ * recharts hands every tick, so the accent survives the class-based tick color
+ * a chart theme may apply. A custom tick owns its own text, so the caller's
+ * `xTickFormatter` is applied here — recharts only applies it to default ticks.
+ * Exported for unit tests; not part of the package's public API.
+ */
+export declare function createForecastTick(forecastX: ReadonlySet<string | number | null | undefined>, color: string, tickFormatter?: CartesianChartProps['xTickFormatter']): ({ payload, index, ...tickProps }: {
+    payload?: {
+        value?: string | number;
+    };
+    index?: number;
+}) => import("react/jsx-runtime").JSX.Element;
+/** A dashed horizontal threshold on the value axis. */
+export interface ConfidenceConeReferenceLine {
+    /** Position on the value (Y) axis. */
+    value: number;
+    /** Optional caption rendered at the line's right end. */
+    label?: string;
+}
+/**
+ * Every prop except the one-form-or-the-other requirement `ConfidenceConeProps`
+ * layers on below. Exported so the stories can type their `Meta` on a single
+ * object shape — Storybook can't split a union's required args between `meta.args`
+ * and a story's. Not re-exported from `index.ts`; not part of the public API.
+ */
+export interface ConfidenceConeBaseProps extends Omit<React.ComponentProps<'div'>, 'children'>, CartesianChartProps, ChartAnimationProps {
     /**
-     * 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.
+     * Row-per-point data — the shared x dimension plus each series' actual /
+     * forecast / bound fields. Rows are naturally sparse (a point has either an
+     * actual or a forecast + bounds), so missing fields are allowed. Avoid fields
+     * starting with `__cone` — that prefix is 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.
+     * yet. Each metric renders in one hue: its cone band and forecast line both
+     * reuse its 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;
+    /**
+     * Plot several metrics against one shared axis — each with its own actual /
+     * forecast / bound fields and its own hue (from `config[actualKey]`). Takes
+     * precedence over the single-series `actualKey`/`forecastKey`/`lowerKey`/
+     * `upperKey` shorthand below; pass one form or the other, not both. One of the
+     * two forms is required.
+     */
+    series?: readonly ConfidenceConeSeries[];
+    /**
+     * Single-series shorthand — field for the known/actual values, drawn as a
+     * solid line with a filled area. Required (with `forecastKey`) unless `series`
+     * is set, which supersedes it.
+     */
+    actualKey?: string;
+    /**
+     * Single-series shorthand — field for the projected values, drawn as a dashed
+     * line. Required (with `actualKey`) unless `series` is set, which supersedes
+     * it.
+     */
+    forecastKey?: string;
+    /** Field for the cone's lower bound. Omit (with `upperKey`) for no cone. */
+    lowerKey?: string;
+    /** Field for the cone's upper bound. Omit (with `lowerKey`) for no cone. */
+    upperKey?: string;
+    /**
+     * How the known/actual period is drawn: a filled `area` under the line (the
+     * default), or a bare `line` — for a chart where the cone is the only shaded
+     * region, or where several metrics' fills would muddy each other.
+     */
+    actualType?: 'area' | 'line';
     /** Stroke width of the actual + forecast lines. */
     strokeWidth?: number;
+    /**
+     * Mark each data point: a filled dot on the observed values, a hollow one on
+     * the projection — so a point reads as measured or predicted at a glance.
+     */
+    showDots?: boolean;
+    /**
+     * Italicize the X-axis ticks over the forecast period and paint them in the
+     * first series' hue, so the projected columns read as projected even when the
+     * shaded region is off.
+     */
+    styleForecastTicks?: boolean;
+    /**
+     * One or more dashed horizontal thresholds on the value axis — e.g. a target
+     * or a capacity limit. Pass a single object or an array to draw several.
+     */
+    referenceLine?: ConfidenceConeReferenceLine | ConfidenceConeReferenceLine[];
     /**
      * 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
@@ -58,5 +157,24 @@ export interface ConfidenceConeProps extends Omit<React.ComponentProps<'div'>, '
     showForecastRegion?: boolean;
     showLegend?: boolean;
 }
-declare const ConfidenceCone: React.ForwardRefExoticComponent<Omit<ConfidenceConeProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Which columns to plot has to be spelled out one way or the other: the `series`
+ * array, or the flat `actualKey` + `forecastKey` shorthand. Expressed as a union
+ * so a chart with neither is a compile error rather than a silent plot of axes
+ * and nothing else. Both forms together stay legal — `series` wins (see
+ * `plotted`), which is what the multi-series stories rely on to clear the args
+ * table.
+ */
+export type ConfidenceConeProps = ConfidenceConeBaseProps & ({
+    series: readonly ConfidenceConeSeries[];
+} | {
+    actualKey: string;
+    forecastKey: string;
+});
+declare const ConfidenceCone: React.ForwardRefExoticComponent<(Omit<ConfidenceConeBaseProps & {
+    series: readonly ConfidenceConeSeries[];
+}, "ref"> | Omit<ConfidenceConeBaseProps & {
+    actualKey: string;
+    forecastKey: string;
+}, "ref">) & React.RefAttributes<HTMLDivElement>>;
 export { ConfidenceCone };

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

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

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

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

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

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

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

@@ -1,10 +1,125 @@
 import { VariantProps } from 'class-variance-authority';
-import { ChartTooltip, ChartConfig } from '../chart';
+import { ChartTooltip, ChartAnimationProps, ChartConfig, TickFormatter } from '../chart';
 import * as React from 'react';
 declare const funnelChartVariants: (props?: ({
     lastShape?: "triangle" | "rectangle" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-export interface FunnelChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, VariantProps<typeof funnelChartVariants> {
+/** Where a stage's label sits relative to its segment. */
+export type FunnelChartLabelPosition = 'right' | 'left' | 'inside';
+/** What a stage's label says. */
+export type FunnelChartLabelFormat = 'name' | 'value' | 'percent' | 'name-value' | 'name-percent' | 'value-percent';
+/** How the stages are coloured: one `config` entry each, or one shared ramp. */
+export type FunnelChartColorMode = 'palette' | 'gradient';
+/** Override for a single stage, keyed by its `nameKey` value. */
+export interface FunnelChartStageSettings {
+    /**
+     * Paint this stage with a colour of its own, overriding both `config` and
+     * `colorMode`. Reference an existing semantic `--ui-*` token.
+     */
+    color?: string;
+    /**
+     * Drop the stage from the funnel — and from the legend, labels and the
+     * conversion percentages, which are computed over the visible stages only.
+     */
+    hidden?: boolean;
+}
+/**
+ * Where the value labels sit when the caller doesn't say: opposite the names, so
+ * the two lists never stack on the same edge. `inside` names sit on the segments
+ * and leave both edges free, so the values take the default `right`.
+ *
+ * A static default can't do this — `valuePosition="left"` beside
+ * `labelPosition="left"` draws both lists at the same anchor, overprinting the
+ * name with its own value.
+ */
+export declare function funnelChartOppositeSide(labelPosition: FunnelChartLabelPosition): FunnelChartLabelPosition;
+/**
+ * Reserve room for a composite label beside the funnel, by narrowing the
+ * **funnel** rather than the plot area.
+ *
+ * recharts word-wraps a label against the space between its trapezoid's
+ * mid-height edge and the *plot area* edge (`getCartesianPosition` clamps
+ * `width` to `parentViewBox`, which `Funnel` sets to the plot box). A margin
+ * shrinks the plot area and the funnel inside it in lockstep, so widening
+ * `margin.right` moves the clamp edge *inward* and leaves a composite label
+ * with less room, not more — the reserved strip sits outside `parentViewBox`
+ * where the text can never reach it.
+ *
+ * `Funnel`'s `width` is the lever that works: it scales the funnel within the
+ * plot area while `parentViewBox` stays put, and because recharts anchors the
+ * funnel at the plot area's left edge (`offsetX = offset.left`), everything it
+ * frees lands on the right. Narrowing the funnel to
+ * `COMPOSITE_FUNNEL_WIDTH` turns ~35px of wrap width into ~140px on a 460px
+ * chart.
+ *
+ * Returns `undefined` — i.e. leave the funnel at its full width — for every
+ * other case, so a funnel with plain labels, no labels, or `inside` labels keeps
+ * exactly the geometry it has always had.
+ *
+ * There is no equivalent lever for `labelPosition="left"`: the widest trapezoid
+ * always starts flush at the plot area's left edge, so a left-hand label is
+ * bounded by how sharply the funnel narrows and narrowing it further only makes
+ * that worse. Composite left-hand labels wrap; that's a recharts limitation, not
+ * a tuning choice.
+ *
+ * A caller-supplied `funnelWidth` always wins — this is only the default.
+ */
+export declare function funnelChartLabelReserve(options: {
+    showLabels: boolean;
+    labelPosition: FunnelChartLabelPosition;
+    labelFormat: FunnelChartLabelFormat;
+}): string | undefined;
+/**
+ * The plot-area margin. Reserves the left inset when a label list sits there, so
+ * a left-hand label isn't clipped at the SVG edge; the right inset is always
+ * reserved, since that is the geometry every existing funnel was drawn with.
+ *
+ * This is overflow protection, not label room — the wrap width comes from
+ * `funnelChartLabelReserve`. A caller-supplied `margin` is merged over these
+ * defaults per side, so `margin={{ right: 160 }}` keeps the default top, bottom
+ * and left rather than collapsing them to zero.
+ */
+export declare function funnelChartLabelMargin(options: {
+    showLabels: boolean;
+    labelPosition: FunnelChartLabelPosition;
+    showValueLabels: boolean;
+    valuePosition: FunnelChartLabelPosition;
+}): {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+/**
+ * Format a conversion share the way the default `percent` label reads it:
+ * `0.52 → "52.0%"`. Exported so a `percentFormatter` can wrap or replace it.
+ */
+export declare const funnelChartPercent: TickFormatter;
+/**
+ * Compose one stage's label text.
+ *
+ * `base` is the value the percentage is measured against — the funnel's widest
+ * stage, not the sum of every stage. A funnel's stages are nested subsets of
+ * each other rather than parts of a whole, so their values don't add up to
+ * anything meaningful; the share that reads as information is the conversion
+ * from the top of the funnel. (A pie's `percent` is the other way round — there
+ * a slice really is a share of the total.)
+ *
+ * Only the numeric part goes through `formatter`, so a label and its tooltip can
+ * share one formatter; the share goes through `percentFormatter`, so a locale
+ * that doesn't write a bare `%` can replace it. The percent formats degrade to
+ * the name (or to the value) rather than printing `NaN%` when there is nothing
+ * to divide by.
+ */
+export declare function funnelChartLabelText(options: {
+    name: string;
+    value: number | string;
+    base: number;
+    format: FunnelChartLabelFormat;
+    formatter?: TickFormatter;
+    percentFormatter?: TickFormatter;
+}): string;
+export interface FunnelChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, VariantProps<typeof funnelChartVariants>, ChartAnimationProps {
     /** Row-per-stage data. Each object holds the stage's `nameKey` label + its `dataKey` numeric value. */
     data: ReadonlyArray<Record<string, string | number>>;
     /**
@@ -24,8 +139,91 @@ export interface FunnelChartProps extends Omit<React.ComponentProps<'div'>, 'chi
     nameKey: string;
     /** Flip the funnel so it widens toward the bottom instead of narrowing. */
     reversed?: boolean;
-    /** Render each stage's name beside its segment. */
+    /** Render a label for each stage — see `labelFormat` and `labelPosition`. */
     showLabels?: boolean;
+    /**
+     * What each stage's label says. `percent` is the stage's share of the widest
+     * stage — its conversion from the top of the funnel.
+     */
+    labelFormat?: FunnelChartLabelFormat;
+    /**
+     * Where each stage's label sits. Defaults to `right`, beside the segment.
+     * `inside` centres it on the segment, which only works while every stage is
+     * wide enough to hold the text — a funnel narrows, so its last stages often
+     * are not. Keep the text short there (`percent`) or leave the labels beside
+     * the funnel.
+     */
+    labelPosition?: FunnelChartLabelPosition;
+    /**
+     * Render a second label carrying the stage's value, so the name and the number
+     * can sit on opposite sides of the funnel.
+     */
+    showValueLabels?: boolean;
+    /**
+     * Where the value label sits. Defaults to the side opposite `labelPosition`,
+     * where every stage has room — so it follows the names rather than pinning
+     * itself to one edge. See `labelPosition` before choosing `inside`.
+     */
+    valuePosition?: FunnelChartLabelPosition;
+    /**
+     * Colour for both label lists, overriding the contrast-matched default (the
+     * on-surface token beside the funnel, the on-fill token on a segment). Pass a
+     * `--ui-*` token; only use it when the default doesn't work on your surface.
+     */
+    labelFill?: string;
+    /** Format the numeric part of a label — pass the same formatter used elsewhere. */
+    labelFormatter?: TickFormatter;
+    /**
+     * Format the conversion share behind the `percent` formats. Receives the share
+     * as a fraction (`0.52`); defaults to `funnelChartPercent` (`"52.0%"`). Pass
+     * `createTickFormatter({ style: 'percent', minimumFractionDigits: 1 }, locale)`
+     * for a locale that doesn't write a bare `%`.
+     */
+    percentFormatter?: TickFormatter;
+    /** Render the legend. Off by default: a funnel labels its stages on the chart. */
+    showLegend?: boolean;
+    /** Which edge the legend sits on. */
+    legendPos?: 'top' | 'bottom';
+    /**
+     * How the stages are coloured. `palette` (the default) gives each stage its own
+     * `config` colour; `gradient` ramps one hue — `gradientColor` — from the widest
+     * stage down to the narrowest.
+     */
+    colorMode?: FunnelChartColorMode;
+    /**
+     * The hue `colorMode="gradient"` ramps. Defaults to the first visible stage's
+     * own colour — including a `stageSettings` colour set on it — so a palette
+     * config becomes a ramp without a second colour decision. Ignored when
+     * `colorMode` is `palette`.
+     */
+    gradientColor?: string;
+    /** Per-stage `color` / `hidden` overrides, keyed by the stage's `nameKey` value. */
+    stageSettings?: Record<string, FunnelChartStageSettings>;
+    /** Outline the hovered segment. */
+    showActiveShape?: boolean;
+    /**
+     * Segment border colour. Reference an existing semantic `--ui-*` token.
+     * Defaults to the border token when `strokeWidth` is set on its own.
+     */
+    stroke?: string;
+    /** Segment border width, in px. Implies a default `stroke` when given alone. */
+    strokeWidth?: number;
+    /**
+     * Funnel width — a number in px or a percentage of the plot area (`'70%'`).
+     * Defaults to the full plot area, except that a composite `labelFormat` beside
+     * the funnel narrows it to leave the label real room to wrap into.
+     */
+    funnelWidth?: number | string;
+    /**
+     * Plot-area margin, in px. Merged over the defaults per side, so passing one
+     * side keeps the others.
+     */
+    margin?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
     showTooltip?: boolean;
     /**
      * Replace the default tooltip. Pass a configured `ChartTooltipContent`

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

@@ -1 +1 @@
-export { FunnelChart, funnelChartVariants, type FunnelChartProps, } from './funnel-chart';
+export { FunnelChart, funnelChartVariants, funnelChartPercent, type FunnelChartProps, type FunnelChartColorMode, type FunnelChartLabelFormat, type FunnelChartLabelPosition, type FunnelChartStageSettings, } from './funnel-chart';

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

@@ -1,4 +1,4 @@
-import { ChartConfig, CartesianChartProps } from '../chart';
+import { ChartConfig, CartesianChartProps, ChartAnimationProps } from '../chart';
 import * as React from 'react';
 export interface HistogramBin {
     /** Lower bound of the bin (inclusive). */
@@ -18,7 +18,7 @@ export interface HistogramBin {
  * 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'>, CartesianChartProps {
+export interface HistogramProps extends Omit<React.ComponentProps<'div'>, 'children'>, CartesianChartProps, ChartAnimationProps {
     /** Raw continuous samples to bin (non-finite values are ignored). */
     values: ReadonlyArray<number>;
     /**

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

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

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

@@ -1,8 +1,8 @@
 import { VariantProps } from 'class-variance-authority';
-import { ChartTooltip, ChartConfig, CartesianChartProps } from '../chart';
+import { ChartTooltip, ChartConfig, CartesianChartProps, ChartAnimationProps, ChartBrushProps, ChartCurveType, ChartDataLabelProps, ChartReferenceLine, CartesianLabelPosition } from '../chart';
 import * as React from 'react';
 declare const lineChartVariants: (props?: ({
-    curve?: "step" | "linear" | "monotone" | null | undefined;
+    curve?: "step" | "linear" | "monotone" | "natural" | "basis" | "stepBefore" | "stepAfter" | null | undefined;
     lineStyle?: "dashed" | "solid" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 /**
@@ -27,7 +27,34 @@ type TooltipRenderProps = Parameters<TooltipContentFn>[0];
  * 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>, 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. one thicker, dashed "target" line among otherwise identical series.
+ *
+ * A series listed in `comparisonKeys` keeps its dashed, dimmed, dot-less
+ * treatment: `color`, `strokeWidth` and `curveType` still apply to it, but
+ * `showDots` / `dotSize` do not (the overlay is defined by having no dots).
+ */
+export interface LineChartLineSettings {
+    /** Stroke color. Defaults to the series' `config` color. */
+    color?: string;
+    /** Stroke width. Defaults to the chart's `strokeWidth`. */
+    strokeWidth?: number;
+    /** Dash this series' stroke, whatever the chart-wide `lineStyle` is. */
+    dashed?: boolean;
+    /** Interpolation for this series only. Defaults to the chart's `curve`. */
+    curveType?: ChartCurveType;
+    /** 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 LineChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, VariantProps<typeof lineChartVariants>, CartesianChartProps, ChartAnimationProps, ChartBrushProps, ChartDataLabelProps {
     /** 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>>;
     /**
@@ -60,9 +87,30 @@ export interface LineChartProps extends Omit<React.ComponentProps<'div'>, 'child
     strokeWidth?: 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 line (`showDots={false}`
+     * with `showActiveDot`) or a static-only line (dots without the hover one).
+     */
+    showActiveDot?: boolean;
     /** Bridge `null` gaps in the data instead of breaking the line. */
     connectNulls?: boolean;
+    /**
+     * Per-series style overrides, keyed by `dataKeys` entry. Series with no entry
+     * render from the chart-wide props.
+     */
+    lineSettings?: Record<string, LineChartLineSettings>;
+    /**
+     * 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.
+     */
+    referenceLine?: ChartReferenceLine | ChartReferenceLine[];
     showLegend?: boolean;
+    /** Position of the value labels when `showLabels` is on. Defaults to `top`. */
+    labelPosition?: CartesianLabelPosition;
 }
 declare const LineChart: React.ForwardRefExoticComponent<Omit<LineChartProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export { LineChart, lineChartVariants };

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

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