@lilt-ui/charts 0.1.0

package/dist/cards/radial-chart-card.d.ts

@@ -0,0 +1,79 @@
+import { CSSProperties, ReactElement, ReactNode } from 'react';
+import { ChartMotion, ChartPalette, ChartStyle, ChartSurface, RankingOrder } from '../types';
+import { CardRange } from './cartesian-card';
+import { NumericKey, TextKey } from './keys';
+import { RankedRow } from './rank';
+import { AnimatedNumberVariant } from '../motion/animated-number';
+export type RadialChartCardVariant = 'donut' | 'pie' | 'semi' | 'rings';
+export interface RadialChartCardProps<Row, Key extends NumericKey<Row>> {
+    title: string;
+    /** One row per category. Omit when `ranges` supplies the data. */
+    data?: readonly Row[];
+    /** Text field that names each slice. Names must be unique. */
+    category: TextKey<Row>;
+    /** Numeric field sized by each slice. Values must not be negative; `null` is "No data". */
+    value: Key;
+    /**
+     * `donut` (default) shows the share in the middle, `pie` fills the circle, `semi` is a half
+     * donut with rounded ends, and `rings` gives each category its own ring on one shared scale.
+     */
+    variant?: RadialChartCardVariant;
+    /**
+     * `list` rows with value and share, value `tiles`, or an `inline` key. Defaults to tiles for
+     * rings, inline for semi, and list otherwise.
+     */
+    legend?: 'list' | 'tiles' | 'inline';
+    /** Resting headline. Defaults to the total of every slice. */
+    headline?: number;
+    /** Fractional change shown as a chip, e.g. 0.082 → +8.2%. */
+    delta?: number;
+    deltaTone?: 'default' | 'inverse' | 'neutral';
+    /** Static period label, e.g. "This month". */
+    range?: string;
+    /** Period select. Each range replaces data, delta, and headline; slices ease to their new size. */
+    ranges?: readonly CardRange<Row>[];
+    defaultRange?: string;
+    /**
+     * Slices shown before the rest are added up as one "Other" slice. Defaults to 5, since more
+     * than six colors stop being told apart. `Infinity` shows every category.
+     */
+    limit?: number;
+    /** Label of the combined slice. Defaults to "Other". */
+    otherLabel?: string;
+    /** `descending` (default) puts the largest first; `input` keeps your order. */
+    sort?: RankingOrder;
+    valueFormat?: Intl.NumberFormatOptions;
+    locale?: string;
+    formatValue?: (value: number) => string;
+    surface?: ChartSurface;
+    /** A glass tab tucked behind the card's top edge, e.g. a caption, a command, or actions. */
+    badge?: ReactNode;
+    /** Headline motion: `count` (default), `pop`, `slide`, `roll`, `flow`, or `scramble`. */
+    numberStyle?: AnimatedNumberVariant;
+    palette?: ChartPalette;
+    loading?: boolean;
+    /** `none` turns off decorative motion; reduced-motion users get this automatically. */
+    motion?: ChartMotion;
+    className?: string;
+    style?: CSSProperties | ChartStyle;
+}
+interface Slice {
+    id: string;
+    startAngle: number;
+    endAngle: number;
+}
+/** Angles for each observed slice, in row order. Missing values take no room. */
+export declare function sliceAngles(rows: readonly RankedRow[]): Slice[];
+/**
+ * The top of a rings scale: the largest value rounded up to a quarter step of its magnitude, so
+ * the longest ring stops short of closing and every ring reads against the same full turn.
+ */
+export declare function ringScale(max: number): number;
+/** One ring per observed row: each sweeps from the top by its value on the shared scale. */
+export declare function ringAngles(rows: readonly RankedRow[]): Slice[];
+/**
+ * A donut or pie card: the headline total, slices with a matching legend, and each slice's
+ * share. Hovering a slice or a legend row reads it in the headline.
+ */
+export declare function RadialChartCard<Row, const Key extends NumericKey<Row>>({ title, data: suppliedData, category, value, variant, legend, headline: suppliedHeadline, delta: suppliedDelta, deltaTone, range, ranges, defaultRange, limit, otherLabel, sort, valueFormat, locale, formatValue: suppliedFormatValue, surface, badge, numberStyle, palette, loading, motion: motionMode, className, style, }: RadialChartCardProps<Row, Key>): ReactElement;
+export {};

package/dist/cards/rank.d.ts

@@ -0,0 +1,21 @@
+import { RankingOrder } from '../types';
+/** One ranked category, or the "Other" row that adds up everything past the limit. */
+export interface RankedRow {
+    id: string;
+    label: string;
+    value: number | null;
+    other?: boolean;
+}
+export declare const OTHER_ID = "\0other";
+export declare const sharePercent: Intl.NumberFormat;
+/** Rank rows, then fold everything past `limit` into one "Other" row. */
+export declare function rankRows<Row>(data: readonly Row[], category: string, value: string, sort: RankingOrder, limit: number | undefined, otherLabel: string): RankedRow[];
+/**
+ * The total of observed values and whether shares of it mean anything: they don't when values
+ * mix gains and losses, or when nothing positive was observed.
+ */
+export declare function shareTotals(rows: readonly RankedRow[]): {
+    observed: number;
+    total: number;
+    shareable: boolean;
+};

package/dist/cards/sankey-chart-card.d.ts

@@ -0,0 +1,69 @@
+import { CSSProperties, ReactElement, ReactNode } from 'react';
+import { SankeyGraph, SankeyLink, SankeyNode } from '../engine/sankey';
+import { ChartMotion, ChartPalette, ChartStyle, ChartSurface } from '../types';
+import { CardRange } from './cartesian-card';
+import { NumericKey, TextKey } from './keys';
+import { AnimatedNumberVariant } from '../motion/animated-number';
+export interface SankeyChartCardProps<Row, Key extends NumericKey<Row>> {
+    title: string;
+    /** One row per flow between two steps. Omit when `ranges` supplies the data. */
+    data?: readonly Row[];
+    /** Text field naming the step a flow leaves. */
+    source: TextKey<Row>;
+    /** Text field naming the step a flow reaches. */
+    target: TextKey<Row>;
+    /** How much moves along the flow. `null` means it wasn't measured and isn't drawn. */
+    value: Key;
+    /**
+     * `loss` (default) lets a step pass on less than it receives, as when visitors leave;
+     * `strict` requires every middle step to pass on exactly what it receives.
+     */
+    conservation?: 'loss' | 'strict';
+    /** Plot height in pixels. Defaults to 280. */
+    height?: number;
+    /** Resting headline. Defaults to everything entering the first steps. */
+    headline?: number;
+    /** Fractional change shown as a chip, e.g. 0.052 → +5.2%. */
+    delta?: number;
+    deltaTone?: 'default' | 'inverse' | 'neutral';
+    /** Static period label, e.g. "Last 7 days". */
+    range?: string;
+    /** Period select. Each range replaces data, delta, and headline; flows redraw left to right. */
+    ranges?: readonly CardRange<Row>[];
+    defaultRange?: string;
+    valueFormat?: Intl.NumberFormatOptions;
+    locale?: string;
+    formatValue?: (value: number) => string;
+    surface?: ChartSurface;
+    /** A glass tab tucked behind the card's top edge, e.g. a caption, a command, or actions. */
+    badge?: ReactNode;
+    /** Headline motion: `count` (default), `pop`, `slide`, `roll`, `flow`, or `scramble`. */
+    numberStyle?: AnimatedNumberVariant;
+    palette?: ChartPalette;
+    loading?: boolean;
+    /** `none` turns off decorative motion; reduced-motion users get this automatically. */
+    motion?: ChartMotion;
+    className?: string;
+    style?: CSSProperties | ChartStyle;
+}
+interface FlowGraph<Row> {
+    graph: SankeyGraph<SankeyNode, SankeyLink & {
+        row: Row;
+    }> | null;
+    error: string | null;
+}
+/** Turn rows of flows into a validated graph; steps take their names from the rows. */
+export declare function sankeyGraph<Row>({ data, source, target, value, conservation, }: {
+    data: readonly Row[];
+    source: string;
+    target: string;
+    value: string;
+    conservation: 'loss' | 'strict';
+}): FlowGraph<Row>;
+/**
+ * A Sankey card: steps as columns of nodes, flows between them as ribbons whose thickness is the
+ * amount that moved. Hovering or stepping through flows with the arrow keys reads each in the
+ * headline with its share of the step it left.
+ */
+export declare function SankeyChartCard<Row, const Key extends NumericKey<Row>>({ title, data: suppliedData, source, target, value, conservation, height, headline: suppliedHeadline, delta: suppliedDelta, deltaTone, range, ranges, defaultRange, valueFormat, locale, formatValue: suppliedFormatValue, surface, badge, numberStyle, palette, loading, motion: motionMode, className, style, }: SankeyChartCardProps<Row, Key>): ReactElement;
+export {};

package/dist/cards/scatter-chart-card.d.ts

@@ -0,0 +1,91 @@
+import { CSSProperties, ReactElement, ReactNode } from 'react';
+import { ChartMotion, ChartPalette, ChartStyle, ChartSurface } from '../types';
+import { CardRange } from './cartesian-card';
+import { NumericKey, TextKey } from './keys';
+import { AnimatedNumberVariant } from '../motion/animated-number';
+/** How the resting headline sums up every plotted point's `y`. */
+export type ScatterAggregate = 'sum' | 'mean' | 'max';
+export interface ScatterChartCardProps<Row, Key extends NumericKey<Row>> {
+    title: string;
+    /** One row per point. Omit when `ranges` supplies the data. */
+    data?: readonly Row[];
+    /** Numeric field for the horizontal position. */
+    x: NumericKey<Row>;
+    /** Numeric field for the vertical position. It also drives the headline. */
+    y: Key;
+    /** Numeric field that sizes each point by area, turning dots into bubbles. */
+    size?: NumericKey<Row>;
+    /** Names the size measure in readouts, e.g. "Reach". */
+    sizeLabel?: string;
+    /** Text field that colors points by group and adds a legend. */
+    group?: TextKey<Row>;
+    /** Text field that names a point when it is hovered or focused. */
+    label?: TextKey<Row>;
+    /** Axis titles, e.g. "Spend" and "Sign-ups". */
+    xLabel?: string;
+    yLabel?: string;
+    /** A least-squares line through the points, with its r² in the footer. */
+    trend?: boolean;
+    /** Plot height in pixels, including the axes. Defaults to 260. */
+    height?: number;
+    /** How the resting headline sums up `y`: `sum` (default), `mean`, or `max`. */
+    aggregate?: ScatterAggregate;
+    /** Resting headline. Defaults to the `aggregate` of every plotted `y`. */
+    headline?: number;
+    /** Fractional change shown as a chip, e.g. 0.052 → +5.2%. */
+    delta?: number;
+    deltaTone?: 'default' | 'inverse' | 'neutral';
+    /** Static period label, e.g. "Last 30 days". */
+    range?: string;
+    /** Period select. Each range replaces data, delta, and headline; points glide to their place. */
+    ranges?: readonly CardRange<Row>[];
+    defaultRange?: string;
+    /** Number format for `y`: the headline, legend, and y axis. */
+    valueFormat?: Intl.NumberFormatOptions;
+    /** Number format for `x`, e.g. `{ style: 'currency', currency: 'USD' }`. */
+    xFormat?: Intl.NumberFormatOptions;
+    locale?: string;
+    formatValue?: (value: number) => string;
+    formatX?: (value: number) => string;
+    /** Any CSS color for the points when there is no `group`. */
+    color?: string;
+    surface?: ChartSurface;
+    /** A glass tab tucked behind the card's top edge, e.g. a caption, a command, or actions. */
+    badge?: ReactNode;
+    /** Headline motion: `count` (default), `pop`, `slide`, `roll`, `flow`, or `scramble`. */
+    numberStyle?: AnimatedNumberVariant;
+    palette?: ChartPalette;
+    loading?: boolean;
+    /** `none` turns off decorative motion; reduced-motion users get this automatically. */
+    motion?: ChartMotion;
+    className?: string;
+    style?: CSSProperties | ChartStyle;
+}
+/**
+ * A readable domain for one axis: rounded to the same ticks the axis draws, anchored at zero when
+ * the data starts near it, and never zero-width.
+ */
+export declare function scatterDomain(values: readonly number[], ticks?: number): [number, number];
+/** Least-squares fit. `null` when fewer than three points or every x is the same. */
+export declare function scatterTrend(points: readonly {
+    x: number;
+    y: number;
+}[]): {
+    slope: number;
+    intercept: number;
+    r2: number;
+} | null;
+/**
+ * The part of the line `y = slope·x + intercept` between `x0` and `x1` that stays inside the y
+ * domain, or `null` when it never enters it.
+ */
+export declare function clipTrend(fit: {
+    slope: number;
+    intercept: number;
+}, [x0, x1]: readonly [number, number], [low, high]: readonly [number, number]): [number, number, number, number] | null;
+/**
+ * A scatter card: one point per row, placed by two measurements and optionally sized by a third
+ * and colored by group. Hovering or stepping through points with the arrow keys reads each one in
+ * the headline, with its position marked on both axes.
+ */
+export declare function ScatterChartCard<Row, const Key extends NumericKey<Row>>({ title, data: suppliedData, x, y, size, sizeLabel, group, label, xLabel, yLabel, trend, height, aggregate, headline: suppliedHeadline, delta: suppliedDelta, deltaTone, range, ranges, defaultRange, valueFormat, xFormat, locale, formatValue: suppliedFormatValue, formatX: suppliedFormatX, color, surface, badge, numberStyle, palette, loading, motion: motionMode, className, style, }: ScatterChartCardProps<Row, Key>): ReactElement;

package/dist/cards/slope-chart-card.d.ts

@@ -0,0 +1,73 @@
+import { CSSProperties, ReactElement, ReactNode } from 'react';
+import { SlopeOrder } from '../engine/slope';
+import { ChartMotion, ChartPalette, ChartStyle, ChartSurface } from '../types';
+import { CardRange } from './cartesian-card';
+import { NumericKey, TextKey } from './keys';
+import { AnimatedNumberVariant } from '../motion/animated-number';
+export type { SlopeOrder } from '../engine/slope';
+export interface SlopeChartCardProps<Row, Key extends NumericKey<Row>> {
+    title: string;
+    /** One row per category with both measurements. Omit when `ranges` supplies the data. */
+    data?: readonly Row[];
+    /** Text field that names each row. Names must be unique. */
+    category: TextKey<Row>;
+    /** Numeric field with the earlier value, e.g. last year. */
+    from: Key;
+    /** Numeric field with the later value, e.g. this year. */
+    to: Key;
+    /** Names the earlier measurement. Defaults to the `from` key. */
+    fromLabel?: string;
+    /** Names the later measurement. Defaults to the `to` key. */
+    toLabel?: string;
+    /**
+     * `slope` (default) joins each category's two values across two columns; `dumbbell` lists
+     * categories as rows with both values on one shared scale.
+     */
+    variant?: 'slope' | 'dumbbell';
+    /** `change` (default) puts the largest gain first, `to` the largest later value, `input` keeps your order. */
+    sort?: SlopeOrder;
+    /**
+     * How the headline and its change summarize categories: `sum` (default) for counts and money,
+     * `mean` for rates and shares.
+     */
+    aggregate?: 'sum' | 'mean';
+    /** Resting headline. Defaults to the later values summarized with `aggregate`. */
+    headline?: number;
+    /**
+     * Fractional change for the chip. Defaults to the change in total across categories measured
+     * at both ends.
+     */
+    delta?: number;
+    /** Direction is not desirability. Use `inverse` when a decrease is good, `neutral` for neither. */
+    deltaTone?: 'default' | 'inverse' | 'neutral';
+    /** Static period label, e.g. "2025 → 2026". */
+    range?: string;
+    /** Period select. Each range replaces data, delta and headline. */
+    ranges?: readonly CardRange<Row>[];
+    defaultRange?: string;
+    /** One color for every category. By default rises and falls take the positive and negative colors. */
+    color?: string;
+    /** Plot height in pixels for the slope variant. Defaults to 260. */
+    height?: number;
+    valueFormat?: Intl.NumberFormatOptions;
+    locale?: string;
+    formatValue?: (value: number) => string;
+    surface?: ChartSurface;
+    /** A glass tab tucked behind the card's top edge, e.g. a caption, a command, or actions. */
+    badge?: ReactNode;
+    /** Headline motion: `count` (default), `pop`, `slide`, `roll`, `flow`, or `scramble`. */
+    numberStyle?: AnimatedNumberVariant;
+    palette?: ChartPalette;
+    loading?: boolean;
+    /** `none` turns off decorative motion; reduced-motion users get this automatically. */
+    motion?: ChartMotion;
+    className?: string;
+    style?: CSSProperties | ChartStyle;
+}
+/**
+ * Two measurements per category, such as last year and this year. The slope variant shows who
+ * rose and who fell at a glance; the dumbbell variant lists the gap for each category. Hovering a
+ * category reads its later value and change in the headline; click pins it, and the arrow keys
+ * move through categories.
+ */
+export declare function SlopeChartCard<Row, const Key extends NumericKey<Row>>({ title, data: suppliedData, category, from, to, fromLabel, toLabel, variant, sort, aggregate, headline: suppliedHeadline, delta: suppliedDelta, deltaTone, range, ranges, defaultRange, color, height, valueFormat, locale, formatValue: suppliedFormatValue, surface, badge, numberStyle, palette, loading, motion: motionMode, className, style, }: SlopeChartCardProps<Row, Key>): ReactElement;

package/dist/cards/stat-card.d.ts

@@ -0,0 +1,68 @@
+import { CSSProperties, ReactElement, ReactNode } from 'react';
+import { ChartBarAppearance, ChartMotion, ChartPalette, ChartStyle, ChartSurface } from '../types';
+import { NumericKey, XKey, XKind } from './keys';
+import { CardAggregate } from './format';
+import { AnimatedNumberVariant } from '../motion/animated-number';
+export type StatCardChart = 'area' | 'line' | 'bars' | 'meter' | 'ring' | 'none';
+export interface StatCardProps<Row, Key extends NumericKey<Row>> {
+    /** The metric's name, e.g. "Revenue". Also names the card for screen readers. */
+    title: string;
+    /** One row per observation. Optional when `headline` is supplied. */
+    data?: readonly Row[];
+    /** Numeric field to summarize and chart. */
+    value?: Key;
+    /** Field that names each observation on hover: text, number, or Date. */
+    x?: XKey<Row>;
+    /** Override x inference. Numbers default to `number`; use `time` for timestamps. */
+    xType?: XKind;
+    /** Resting value. Defaults to `value` summarized with `aggregate`. */
+    headline?: number;
+    /**
+     * How the resting value summarizes the data: `sum` (default) for counts and money, `mean` or
+     * `max` for rates, `last` for levels such as active users.
+     */
+    aggregate?: CardAggregate;
+    /** Fractional change shown as a chip, e.g. 0.082 → +8.2%. */
+    delta?: number;
+    deltaTone?: 'default' | 'inverse' | 'neutral';
+    /** Quiet text beside the delta, e.g. "vs last month". */
+    caption?: string;
+    /**
+     * The small chart: `area` (default), `line`, or `bars` under the value; a `meter` of cells or a
+     * `ring` beside the value, both filling toward `target`; or `none`.
+     */
+    chart?: StatCardChart;
+    /** Bar treatment for `chart="bars"`: `solid` (default), `segmented`, `needle`, `gradient`, `outline`. */
+    barStyle?: ChartBarAppearance;
+    /** Goal for `chart="meter"` or `chart="ring"`, in the same unit as the value. */
+    target?: number;
+    /**
+     * Link the small chart's hover with every card that uses the same name, matched by `x`.
+     * Requires `x`.
+     */
+    sync?: string;
+    /** Chart height in pixels. Defaults to 56 (also the ring's size), or 10 for a meter. */
+    height?: number;
+    /** Any CSS color. Defaults to the palette's first color. */
+    color?: string;
+    /** Right side of the header, e.g. an icon or a menu. */
+    aside?: ReactNode;
+    valueFormat?: Intl.NumberFormatOptions;
+    locale?: string;
+    formatValue?: (value: number) => string;
+    formatX?: (value: string | number | Date) => string;
+    /** `elevated` (default), `outline`, or `ghost` inside your own card. */
+    surface?: ChartSurface;
+    /** A glass tab tucked behind the card's top edge, e.g. a caption, a command, or actions. */
+    badge?: ReactNode;
+    /** Headline motion: `count` (default), `pop`, `slide`, `roll`, `flow`, or `scramble`. */
+    numberStyle?: AnimatedNumberVariant;
+    palette?: ChartPalette;
+    loading?: boolean;
+    motion?: ChartMotion;
+    className?: string;
+    style?: CSSProperties | ChartStyle;
+}
+/** Cells of a meter: whole cells up to the value, then one cell trimmed to the exact remainder. */
+export declare function meterCells(ratio: number, count?: number): number[];
+export declare function StatCard<Row, const Key extends NumericKey<Row>>({ title, data, value: valueKey, x, xType, headline: suppliedHeadline, aggregate, delta, deltaTone, caption, chart, barStyle, target, sync, height, color, aside, valueFormat, locale, formatValue: suppliedFormatValue, formatX, surface, badge, numberStyle, palette, loading, motion, className, style, }: StatCardProps<Row, Key>): ReactElement;

package/dist/chart-context.d.ts

@@ -0,0 +1,102 @@
+import { ChartBarLayout, ChartMargins, ChartSeries, ChartXConfig, ChartYConfig } from './types';
+import { NormalizedData } from './engine/normalize';
+import { PlotGeometry } from './engine/geometry';
+import { StackMode } from './engine/stack';
+export declare const DEFAULT_MARGINS: ChartMargins;
+export interface PlotBox {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    right: number;
+    bottom: number;
+}
+/** Which series a plot draws as bars and which it stacks, resolved from its props. */
+export interface PlotArrangement {
+    /** Series drawn as bars, or null for none. Stacked bars draw exactly the stack's series. */
+    bars: readonly string[] | null;
+    /** Series that stack, in chart series order, and how they combine. */
+    stack: {
+        series: readonly string[];
+        mode: StackMode;
+    } | null;
+}
+export declare const LINE_ARRANGEMENT: PlotArrangement;
+export interface ChartSnapshot<T> {
+    bars: readonly string[] | null;
+    /** `signed` marks a sum stack with values below zero. */
+    stack: {
+        series: readonly string[];
+        mode: StackMode;
+        signed: boolean;
+    } | null;
+    barLayout: ChartBarLayout;
+    stackWeights?: Readonly<Record<string, number>>;
+    data: NormalizedData<T>;
+    xDomain: readonly [number, number];
+    yDomain: readonly [number, number] | null;
+    xTicks: readonly number[];
+    yTicks: readonly number[];
+    xToPixel: (value: number) => number;
+    yToPixel: (value: number) => number;
+    geometry: PlotGeometry | null;
+    plot: PlotBox;
+    formatX: (value: number) => string;
+    formatY: (value: number) => string;
+    /** Raw measurements retain their unit when the plotted axis is normalized. */
+    formatValue: (value: number) => string;
+    /**
+     * Present when some series use `scale: 'secondary'`: their values equal primary values times
+     * `factor`, so they share the primary ticks.
+     */
+    secondary: {
+        factor: number;
+        format: (value: number) => string;
+    } | null;
+}
+export interface AxisTick {
+    value: number;
+    entering?: boolean;
+    leaving?: boolean;
+}
+export interface ChartContextValue<T> {
+    snapshot: ChartSnapshot<T>;
+    previousSnapshot: ChartSnapshot<T> | null;
+    series: readonly ChartSeries<T>[];
+    xConfig: ChartXConfig<T>;
+    yConfig: ChartYConfig;
+    margins: ChartMargins;
+    width: number;
+    height: number;
+    revealProgress: number;
+    reducedMotion: boolean;
+    transitionDuration: number;
+    transitionKind: 'initial' | 'handoff' | 'matched-update' | 'topology-update' | null;
+    axis: {
+        x: readonly AxisTick[];
+        y: readonly AxisTick[];
+    };
+    clipId: string;
+    gridGradientId: string;
+    paintId: (seriesId: string, treatment: 'fade' | 'hatch' | 'dots') => string;
+    inspectionSeries?: string;
+    inspecting: boolean;
+    focusedSeries?: string | null;
+    visibleSeries: readonly string[];
+}
+declare const ChartContext: import('react').Context<ChartContextValue<unknown> | null>;
+export declare function ChartContextProvider<T>({ value, children, }: {
+    value: ChartContextValue<T>;
+    children: React.ReactNode;
+}): React.ReactElement;
+export declare function useChartContext<T>(): ChartContextValue<T>;
+export declare function defaultXFormatter(type: 'time' | 'number', value: number): string;
+export declare function defaultYFormatter(value: number): string;
+export declare function makeAxisTicks(snapshot: ChartSnapshot<unknown>, previous: ChartSnapshot<unknown> | undefined): {
+    x: AxisTick[];
+    y: AxisTick[];
+};
+export declare function buildSnapshot<T>(data: NormalizedData<T>, series: readonly ChartSeries<T>[], xConfig: ChartXConfig<T>, yConfig: ChartYConfig, margins: ChartMargins, width: number, height: number, yDomainOverride?: readonly [number, number] | null, xDomainOverride?: readonly [number, number] | null, geometrySeries?: readonly ChartSeries<T>[], arrangement?: PlotArrangement, stackWeights?: Readonly<Record<string, number>>, barLayout?: ChartBarLayout, 
+/** Keeps line and area observations off the plot edges so labels can center on them. */
+edgeInset?: number): ChartSnapshot<T>;
+export { ChartContext };

package/dist/chart-plot.d.ts

@@ -0,0 +1,13 @@
+import { ReactElement } from 'react';
+import { ChartBars, ChartPlotProps, ChartStack, ChartStackMode } from './types';
+import { CartesianChartModel } from './model/cartesian-model';
+export type ModelChartPlotProps<Row, Id extends string> = Omit<ChartPlotProps, 'bars' | 'stack'> & {
+    model: CartesianChartModel<Row, Id>;
+    bars?: true | ChartBars<NoInfer<Id>>;
+    stack?: true | ChartStackMode | ChartStack<NoInfer<Id>>;
+    inspectionSeries?: NoInfer<Id>;
+};
+export declare function ChartPlot<Row, Id extends string>(props: ModelChartPlotProps<Row, Id>): ReactElement;
+export declare function ChartPlot(props: ChartPlotProps & {
+    model?: never;
+}): ReactElement;

package/dist/chart.d.ts

@@ -0,0 +1,17 @@
+import { ReactElement, ReactNode } from 'react';
+import { PlotArrangement } from './chart-context';
+import { ChartBarLayout, ChartPlotProps, ChartProps } from './types';
+import { ToolkitStore } from './runtime/chart-runtime';
+import { CartesianChartModel } from './model/cartesian-model';
+type ChartPlotRendererProps<T> = Omit<ChartProps<T>, 'className' | 'style'> & Omit<ChartPlotProps, 'bars' | 'stack' | 'tooltip'> & {
+    arrangement?: PlotArrangement;
+    barLayout?: ChartBarLayout;
+    selectedCategoryId?: string | null;
+    onSelectedCategoryIdChange?: (id: string | null) => void;
+    toolkit: ToolkitStore;
+    model?: CartesianChartModel<T, string>;
+    controllerLinked?: boolean;
+    tooltipNode?: ReactNode;
+};
+export declare function ChartPlotRenderer<T>({ data, x, y, series, height, compactHeight, margins: marginProps, arrangement, barLayout: barsProps, compact, tooltipNode, inspectionSeries: plotInspectionSeries, className, style, 'aria-label': ariaLabel, children, status, interactive, error, renderRetry, motion: motionPreference, animateIn, resetKey, onSelectionChange, controller, linkedSelection, selectedCategoryId, onSelectedCategoryIdChange, compare, focus, live, brush, visibleSeries, onVisibleSeriesChange, toolkit, model, controllerLinked, axis: axisStyle, pill, pillSeries, pillValue, pillPosition, axisInset, runoff, labelOverhang, }: ChartPlotRendererProps<T>): ReactElement;
+export {};

package/dist/data/chart-data.d.ts

@@ -0,0 +1,24 @@
+import { ChartRange } from '../types';
+export interface ChartSummary {
+    count: number;
+    missing: number;
+    total: number | null;
+    mean: number | null;
+    min: number | null;
+    max: number | null;
+    first: number | null;
+    last: number | null;
+    change: number | null;
+}
+/** Inclusive bounds; missing observations are counted, never silently turned into zero. */
+export declare function summarizeRange<T>(data: readonly T[], options: {
+    x: (row: T) => number | Date;
+    value: (row: T) => number | null;
+    range?: ChartRange | null;
+}): ChartSummary;
+export interface CsvColumn<T> {
+    header: string;
+    value: (row: T) => string | number | boolean | Date | null;
+}
+/** RFC 4180 fields, UTC dates, blank nulls and spreadsheet-safe text cells. No browser side effects. */
+export declare function toChartCsv<T>(data: readonly T[], columns: readonly CsvColumn<T>[]): string;

package/dist/data.d.ts

@@ -0,0 +1,5 @@
+/** Server-safe data operations. This entry does not import the interactive chart runtime. */
+export { summarizeRange, toChartCsv } from './data/chart-data';
+export type { ChartSummary, CsvColumn } from './data/chart-data';
+export { funnelRows as summarizeFunnelStages } from './engine/analysis';
+export type { FunnelRow as FunnelStageSummary } from './engine/analysis';

package/dist/data.js

@@ -0,0 +1,2 @@
+import { o as e, s as t, t as n } from "./analysis-BLLWEKBw.js";
+export { n as summarizeFunnelStages, e as summarizeRange, t as toChartCsv };

package/dist/engine/analysis.d.ts

@@ -0,0 +1,11 @@
+import { RankingCategory, RankingRow } from './ranking';
+export interface FunnelRow<T> extends RankingRow<T> {
+    share: number | null;
+    conversion: number | null;
+    drop: number | null;
+}
+export declare function funnelRows<T>(props: {
+    data: readonly T[];
+    category: RankingCategory<T>;
+    value: (row: T) => number | null;
+}): FunnelRow<T>[];

package/dist/engine/bars.d.ts

@@ -0,0 +1,38 @@
+export interface BarGeometry {
+    /** Original observation identity, never a pixel coordinate. */
+    valueX: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    baseline: number;
+    negative: boolean;
+}
+/** Preserve real time/numeric spacing, including gaps, while keeping edge bars inside the plot. */
+export declare function barSpacing(values: readonly number[], span: number, width: number): {
+    inset: number;
+    slot: number;
+    groupWidth: number;
+};
+/** Whether a later nonempty segment covers this segment's value end. */
+export declare function hasStackedSuccessor(geometry: Readonly<Record<string, readonly BarGeometry[]>>, seriesIds: readonly string[], seriesId: string, bar: BarGeometry): boolean;
+/** Round exposed value ends or both ends; trim covered ends to create deliberate gaps. */
+export declare function barPath(bar: BarGeometry, progress?: number, options?: {
+    originY?: number;
+    roundValueEnd?: boolean;
+    roundBothEnds?: boolean;
+    radius?: number;
+    valueGap?: number;
+}): string;
+/** Use one path rule for resting marks and inspection highlights. */
+export declare function barMarkPath(bar: BarGeometry, options: {
+    stacked: boolean;
+    geometry: Readonly<Record<string, readonly BarGeometry[]>>;
+    seriesIds: readonly string[];
+    seriesId: string;
+    radius?: number;
+    roundBothEnds?: boolean;
+    segmentGap?: number;
+    progress?: number;
+    originY?: number;
+}): string;

package/dist/engine/comparison.d.ts

@@ -0,0 +1,3 @@
+import { ChartComparison, ChartPercentagePolicy, ChartRange } from '../types';
+import { NormalizedData } from './normalize';
+export declare function comparisonForRange<T>(data: NormalizedData<T>, range: ChartRange, series: string, percentage?: ChartPercentagePolicy): ChartComparison;

package/dist/engine/composition.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Shares in percentage points, preserving measured zero. A missing, invalid, negative,
+ * or zero-total period has no meaningful composition and returns gaps for every series.
+ * Scaling before summing also supports large finite inputs without overflowing.
+ */
+export declare function compositionShares(values: readonly unknown[]): (number | null)[];

package/dist/engine/domains.d.ts

@@ -0,0 +1,13 @@
+import { ChartSeries, ChartYConfig } from '../types';
+import { NormalizedData } from './normalize';
+export declare function computeYDomain<T>(data: NormalizedData<T>, series: readonly ChartSeries<T>[], config?: ChartYConfig): readonly [number, number];
+export declare function interpolateDomain(from: readonly [number, number], to: readonly [number, number], progress: number): readonly [number, number];
+/** The smallest of 1, 2, 2.5, 5 × 10ⁿ at or above `value`. */
+export declare function niceCeil(value: number): number;
+/**
+ * A second value scale that shares the primary scale's gridlines: every secondary value is the
+ * primary value times one factor, so zero and every tick line up, and the factor is chosen so
+ * the secondary ticks land on round numbers. Returns null when the primary domain excludes zero
+ * or the secondary values cannot fit on the same side of it.
+ */
+export declare function alignedSecondaryFactor(primary: readonly [number, number], primaryStep: number, values: readonly number[]): number | null;