@acronis-platform/ui-react 0.58.0 → 0.61.0

package/dist/react.js.map

@@ -1 +1 @@
-{"version":3,"file":"react.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"react.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

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

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

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

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

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

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

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

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

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

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

@@ -2,7 +2,7 @@ import { useRender } from '@base-ui/react/use-render';
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const buttonVariants: (props?: ({
-    variant?: "destructive" | "ai" | "default" | "secondary" | "ghost" | null | undefined;
+    variant?: "destructive" | "ai" | "secondary" | "default" | "ghost" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
     /**

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

@@ -2,7 +2,7 @@ import { useRender } from '@base-ui/react/use-render';
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const buttonMenuVariants: (props?: ({
-    variant?: "secondary" | "primary" | null | undefined;
+    variant?: "primary" | "secondary" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface ButtonMenuProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'>, VariantProps<typeof buttonMenuVariants> {
     /**

package/dist/src/components/ui/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/__tests__/chart-layout.d.ts

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

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

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