@sophistry/charts 0.0.0-stage → 0.0.1

package/dist/radial/pie-chart.d.ts

@@ -0,0 +1,144 @@
+/**
+ * `pieChart`: a pie (or doughnut) of one wedge per datum.
+ *
+ * The wedges draw as one path batch: each item is the native curve outline
+ * of a `sector` (or `annularSector`, with a hole), with its own
+ * fill; the stroke, its width and the fill opacity are shared. Per-wedge
+ * picking and accessible names go through the batch's items (`event.item`,
+ * `itemLabel`). Slice labels stay `label` nodes, one per present slice.
+ */
+import type { ColorInput } from "@sophistry/core";
+import type { BandKey, Point } from "@sophistry/core/geometry";
+import type { Channel, ColorChannel, RequiredUnless } from "../data/channels";
+import type { KeyedJoin } from "../math/join";
+import type { KeyedTransitionProps, RadialReveal } from "../props";
+/** @category Charts */
+export interface PieChartBaseProps<T> extends KeyedTransitionProps<T> {
+    /** One slice per datum. */
+    data: readonly T[];
+    /**
+     * The slice's value, in data units. Defaults to the datum when `data` is `number[]`; required
+     * otherwise. Negative and non-finite values count as 0 (an empty slice).
+     */
+    value?: Channel<T, number>;
+    /**
+     * The slice's visible label. Omitted, a rounded percentage. See `ariaLabel` for the accessible
+     * name.
+     */
+    label?: Channel<T, string>;
+    /**
+     * The chart's accessible name; each slice is announced as `"<ariaLabel>: <slice label>"`.
+     * Omitted, slices are not exposed to assistive technology.
+     */
+    ariaLabel?: string;
+    /** Centre of the chart. Defaults to the origin. */
+    center?: Point;
+    /**
+     * Outer radius.
+     * @default 1
+     */
+    radius?: number;
+    /**
+     * Radius of a hole through the centre, making a doughnut chart. `0` draws a plain pie.
+     * @default 0
+     */
+    innerRadius?: number;
+    /**
+     * Reveal, 0..1: `reveal="grow"` opens every slice at once, keeping their true ratio, until they
+     * close the circle; `"sweep"` wipes round the pie, uncovering slices in data order.
+     * @default 1
+     * @see https://sophistry.dev/guides/chart-animation/#reveals
+     */
+    progress?: number;
+    reveal?: RadialReveal;
+    /**
+     * Angle the first slice begins at, in radians from +x. The default is 12 o'clock.
+     * @default Math.PI / 2
+     */
+    startAngle?: number;
+    /**
+     * Whether slices run clockwise.
+     * @default true
+     */
+    clockwise?: boolean;
+    /** One colour for every slice, or `(d, i) => colour`. Wins over `colors`. */
+    color?: ColorChannel<T>;
+    /** Colours cycled across the slices by index. Defaults to the theme's categorical colours. */
+    colors?: readonly ColorInput[];
+    /**
+     * Whether to draw slice labels.
+     * @default true
+     */
+    labels?: boolean;
+    /** Label font size. */
+    labelFontSize?: number;
+    /** Label colour. Defaults to the theme background. */
+    labelColor?: ColorInput;
+    /**
+     * Each slice's identity across transitions. See {@link KeyedTransitionProps}. Defaults to
+     * `label`, else the index.
+     */
+    key?: Channel<T, BandKey>;
+    /**
+     * The data to transition to, matched to `data` by `key`: values blend and the pie is re-laid
+     * out every frame, so the slices always fill the turn; leaving slices shrink away, new ones
+     * open up. See {@link KeyedTransitionProps}.
+     * @see https://sophistry.dev/guides/chart-animation/#data-transitions
+     */
+    to?: readonly T[];
+    /** Slice outline. Defaults to the theme background. */
+    stroke?: ColorInput;
+    /**
+     * Outline width.
+     * @default 0.02
+     */
+    strokeWidth?: number;
+    /** Fill opacity of the slices, 0..1. */
+    fillOpacity?: number;
+    /** Paint order. */
+    zIndex?: number;
+    /** Set to false to hide the chart. */
+    visible?: boolean;
+}
+/**
+ * Props of {@link pieChart}: `value` is required unless `data` is `number[]`.
+ *
+ * @category Charts
+ */
+export type PieChartProps<T> = PieChartBaseProps<T> & RequiredUnless<T, number, "value">;
+/**
+ * A pie chart, or a doughnut with `innerRadius`: one slice per value, sized by its share of
+ * the total, separated by a thin background-coloured outline. Draws in scene units; nothing is
+ * drawn if every value is 0. The slices are one path batch (`event.item` is the slice's place
+ * among the drawn ones). See {@link pieSlices} for the angle math alone.
+ *
+ * @example
+ * ```ts
+ * import { pieChart } from "@sophistry/charts";
+ *
+ * pieChart.create({
+ * 	data: [
+ * 		{ lang: "Rust", share: 3 },
+ * 		{ lang: "Go", share: 2 },
+ * 	],
+ * 	value: "share",
+ * 	label: "lang",
+ * 	innerRadius: 0.4,
+ * });
+ * ```
+ *
+ * @see https://sophistry.dev/reference/chart-catalogue/#pie-polar-area-and-radar
+ * @category Charts
+ */
+export declare const pieChart: import("@sophistry/core").Definition<PieChartBaseProps<any>, import("@sophistry/core/internal").CompositeNode<PieChartBaseProps<any>>, keyof PieChartBaseProps<any>>;
+/** Both ends' ring orders. */
+export interface RingOrders {
+    from: readonly BandKey[];
+    to: readonly BandKey[];
+}
+/**
+ * The ring order at each end: one order unless the keys both ends have are
+ * reordered. Memoise it on the join (kept by identity while the keys hold).
+ */
+export declare function ringOrders(join: KeyedJoin | undefined, keys: readonly BandKey[]): RingOrders;
+//# sourceMappingURL=pie-chart.d.ts.map

package/dist/radial/pie-chart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pie-chart.d.ts","sourceRoot":"","sources":["../../src/radial/pie-chart.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACX,UAAU,EAMV,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAG/D,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAU9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAK9C,OAAO,KAAK,EAAY,oBAAoB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAsB7E,uBAAuB;AACvB,MAAM,WAAW,iBAAiB,CAAC,CAAC,CAAE,SAAQ,oBAAoB,CAAC,CAAC,CAAC;IACpE,2BAA2B;IAC3B,IAAI,EAAE,SAAS,CAAC,EAAE,CAAC;IACnB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IAC3B;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IAC3B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,MAAM,CAAC,EAAE,KAAK,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IACxB,8FAA8F;IAC9F,MAAM,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IAC/B;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,uBAAuB;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sDAAsD;IACtD,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB;;;OAGG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAC1B;;;;;OAKG;IACH,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC;IAClB,uDAAuD;IACvD,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wCAAwC;IACxC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mBAAmB;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sCAAsC;IACtC,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,iBAAiB,CAAC,CAAC,CAAC,GAClD,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AA0NpC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,QAAQ,sKA2DnB,CAAC;AAEH,8BAA8B;AAC9B,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,SAAS,OAAO,EAAE,CAAC;IACzB,EAAE,EAAE,SAAS,OAAO,EAAE,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACzB,IAAI,EAAE,SAAS,GAAG,SAAS,EAC3B,IAAI,EAAE,SAAS,OAAO,EAAE,GACtB,UAAU,CAKZ"}

package/dist/radial/polar-area-chart.d.ts

@@ -0,0 +1,136 @@
+/**
+ * `polarAreaChart`: a rose of equal-angle wedges whose radius carries the
+ * value.
+ *
+ * The wedges draw as one path batch (each item the native outline of a
+ * `sector`, with its own fill); per-wedge picking and accessible names
+ * go through its items. Wedge labels stay `label` nodes. Inside a chart the
+ * layer reports its series (for the legend) and its transition (for the
+ * staging); it fits no axes.
+ */
+import type { ColorInput } from "@sophistry/core";
+import type { BandKey, Point } from "@sophistry/core/geometry";
+import type { Channel, ColorChannel, RequiredUnless } from "../data/channels";
+import type { KeyedTransitionProps, RevealProps } from "../props";
+/** @category Charts */
+export interface PolarAreaChartBaseProps<T> extends KeyedTransitionProps<T>, RevealProps {
+    /** One wedge per datum. */
+    data: readonly T[];
+    /**
+     * The wedge's value, in data units. Defaults to the datum when `data` is `number[]`; required
+     * otherwise. Negative and non-finite values count as 0 (an empty wedge).
+     */
+    value?: Channel<T, number>;
+    /**
+     * The wedge's visible label. Omitted, a rounded percentage. See `ariaLabel` for the accessible
+     * name.
+     */
+    label?: Channel<T, string>;
+    /**
+     * The chart's accessible name; each wedge is announced as `"<ariaLabel>: <wedge label>"`.
+     * Omitted, wedges are not exposed to assistive technology.
+     */
+    ariaLabel?: string;
+    /** Centre of the chart. Defaults to the origin. */
+    center?: Point;
+    /**
+     * Radius a value of `maxValue` reaches.
+     * @default 1
+     */
+    radius?: number;
+    /**
+     * The value that reaches `radius`. Pin it to keep the scale fixed as `data` changes. Defaults
+     * to the greatest value in `data`.
+     */
+    maxValue?: number;
+    /**
+     * Angle the first wedge begins at, in radians from +x. The default is 12 o'clock.
+     * @default Math.PI / 2
+     */
+    startAngle?: number;
+    /**
+     * Whether wedges run clockwise.
+     * @default true
+     */
+    clockwise?: boolean;
+    /**
+     * Reveal, 0..1: one sweep round the chart from `startAngle`, uncovering wedges in data order.
+     * @default 1
+     * @see https://sophistry.dev/guides/chart-animation/#reveals
+     */
+    progress?: number;
+    /**
+     * Fraction of the reveal spent staggering wedge after wedge, 0..0.95; 0 opens every wedge
+     * together. Defaults to one continuous sweep, `(n − 1) / n`.
+     */
+    stagger?: number;
+    /**
+     * The category of each wedge: colours wedges through the chart's shared colour scale and
+     * legend. `color` and `colors` win.
+     */
+    series?: Channel<T, BandKey>;
+    /** One colour for every wedge, or `(d, i) => colour`. Wins over `colors` and `series`. */
+    color?: ColorChannel<T>;
+    /**
+     * Colours cycled across the wedges by index. Wins over `series`. Defaults to the `series`
+     * colours, else the theme's categorical colours.
+     */
+    colors?: readonly ColorInput[];
+    /**
+     * Whether to draw wedge labels.
+     * @default true
+     */
+    labels?: boolean;
+    /** Label font size. */
+    labelFontSize?: number;
+    /** Label colour. Defaults to the theme background. */
+    labelColor?: ColorInput;
+    /**
+     * Each wedge's identity across transitions. See {@link KeyedTransitionProps}. Defaults to
+     * `label`, else the place within its `series`, else the index.
+     */
+    key?: Channel<T, BandKey>;
+    /**
+     * The data to transition to, matched to `data` by `key`: wedges reach out or draw in to their
+     * new value; leaving wedges narrow away and new ones open up as the rest make room. See {@link
+     * KeyedTransitionProps}.
+     * @see https://sophistry.dev/guides/chart-animation/#data-transitions
+     */
+    to?: readonly T[];
+    /** Wedge outline. Defaults to the theme background. */
+    stroke?: ColorInput;
+    /**
+     * Outline width.
+     * @default 0.02
+     */
+    strokeWidth?: number;
+    /** Fill opacity of the wedges, 0..1. */
+    fillOpacity?: number;
+    /** Paint order. */
+    zIndex?: number;
+    /** Set to false to hide the chart. */
+    visible?: boolean;
+}
+/**
+ * Props of {@link polarAreaChart}: `value` is required unless `data` is `number[]`.
+ *
+ * @category Charts
+ */
+export type PolarAreaChartProps<T> = PolarAreaChartBaseProps<T> & RequiredUnless<T, number, "value">;
+/**
+ * A polar area (rose) chart: wedges of equal angle whose radius carries the value, linear
+ * against `maxValue`. Draws in scene units; zero-value wedges are skipped. The wedges are one
+ * path batch. See {@link polarAreaSlices} for the wedge math alone.
+ *
+ * @example
+ * ```ts
+ * import { polarAreaChart } from "@sophistry/charts";
+ *
+ * polarAreaChart.create({ data: [4, 2, 3, 1], labels: false, stagger: 0.4 });
+ * ```
+ *
+ * @see https://sophistry.dev/reference/chart-catalogue/#pie-polar-area-and-radar
+ * @category Charts
+ */
+export declare const polarAreaChart: import("@sophistry/core").Definition<PolarAreaChartBaseProps<any>, import("@sophistry/core/internal").CompositeNode<PolarAreaChartBaseProps<any>>, keyof PolarAreaChartBaseProps<any>>;
+//# sourceMappingURL=polar-area-chart.d.ts.map

package/dist/radial/polar-area-chart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polar-area-chart.d.ts","sourceRoot":"","sources":["../../src/radial/polar-area-chart.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACX,UAAU,EAMV,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAS/D,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAkB9E,OAAO,KAAK,EAAY,oBAAoB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAkB5E,uBAAuB;AACvB,MAAM,WAAW,uBAAuB,CAAC,CAAC,CACzC,SAAQ,oBAAoB,CAAC,CAAC,CAAC,EAC9B,WAAW;IACZ,2BAA2B;IAC3B,IAAI,EAAE,SAAS,CAAC,EAAE,CAAC;IACnB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IAC3B;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IAC3B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,MAAM,CAAC,EAAE,KAAK,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAC7B,0FAA0F;IAC1F,KAAK,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IACxB;;;OAGG;IACH,MAAM,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IAC/B;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,uBAAuB;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sDAAsD;IACtD,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB;;;OAGG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAC1B;;;;;OAKG;IACH,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC;IAClB,uDAAuD;IACvD,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wCAAwC;IACxC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mBAAmB;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sCAAsC;IACtC,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,uBAAuB,CAAC,CAAC,CAAC,GAC9D,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AA2UpC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,wLAiEzB,CAAC"}

package/dist/radial/radar-chart.d.ts

@@ -0,0 +1,177 @@
+/**
+ * `radarChart`: one polygon per series on evenly spaced axes, over a grid of
+ * rings and spokes, with axis names outside.
+ *
+ * The series polygons draw as one path batch (each item a series' outline
+ * with its own fill and stroke colour; fill opacity and stroke width
+ * shared). Under `reveal="sweep"` the clip groups are one wedge that
+ * clips every series while the series' reveal plays, and a series coming or
+ * going (each series, under a staggered sweep) is clipped to its own wedge
+ * inside it. A path batch has one clip, so the series split into runs, each
+ * run a batch under its own pair of groups: one run (one batch) when no
+ * series has a wedge of its own. The grid rings and spokes stay
+ * `polygon` / `line` nodes: they reveal by tracing their stroke
+ * (`progress`), which a path batch does not do per item, and there are a
+ * handful of them. Axis names are `label` nodes.
+ */
+import type { ColorInput } from "@sophistry/core";
+import type { BandKey, ClosedCurveKind, Point } from "@sophistry/core/geometry";
+import type { Channel, ColorChannel, RequiredUnless } from "../data/channels";
+import type { KeyedTransitionProps, RadialReveal, RevealProps, StaggerOrder } from "../props";
+/** @category Charts */
+export interface RadarChartBaseProps<T> extends KeyedTransitionProps<T>, RevealProps {
+    /** One polygon per datum (a series), all read against the same axes and `maxValue`. */
+    data: readonly T[];
+    /**
+     * The series' value on each axis, one entry per axis. Defaults to the datum when `data` is
+     * `number[][]`; required otherwise.
+     */
+    axisValues?: Channel<T, readonly number[]>;
+    /**
+     * One name per axis, drawn outside the rings; when given, every non-empty group must have
+     * exactly that many values or the chart throws. `false` draws no names; `true` draws them even
+     * when only `toAxisLabels` names the axes.
+     */
+    axisLabels?: boolean | readonly string[];
+    /** Centre of the chart. Defaults to the origin. */
+    center?: Point;
+    /**
+     * Radius a value of `maxValue` reaches.
+     * @default 1
+     */
+    radius?: number;
+    /**
+     * The value that reaches `radius`. Pin it to keep the scale fixed as `data` changes. Defaults
+     * to the greatest value across every series.
+     */
+    maxValue?: number;
+    /**
+     * Angle of the first axis, in radians from +x. The default is 12 o'clock.
+     * @default Math.PI / 2
+     */
+    startAngle?: number;
+    /**
+     * Whether axes run clockwise.
+     * @default true
+     */
+    clockwise?: boolean;
+    /**
+     * The category of each polygon: colours polygons through the chart's shared colour scale and
+     * legend. `color` and `colors` win.
+     */
+    series?: Channel<T, BandKey>;
+    /**
+     * Each polygon's identity across data changes and transitions. See {@link
+     * KeyedTransitionProps}. Defaults to the datum's place within its `series`, else its index.
+     */
+    key?: Channel<T, BandKey>;
+    /** One colour for every series, or `(d, i) => colour`. Wins over `colors` and `series`. */
+    color?: ColorChannel<T>;
+    /**
+     * Colours cycled across the series by index. Wins over `series`. Defaults to the `series`
+     * colours, else the theme's categorical colours.
+     */
+    colors?: readonly ColorInput[];
+    /**
+     * Fill opacity of each polygon.
+     * @default 0.25
+     */
+    fillOpacity?: number;
+    /**
+     * Outline width of each polygon.
+     * @default 0.02
+     */
+    strokeWidth?: number;
+    /**
+     * Number of concentric grid rings under the data.
+     * @default 4
+     */
+    gridRings?: number;
+    /**
+     * Whether to draw the grid rings and spokes.
+     * @default true
+     */
+    grid?: boolean;
+    /**
+     * Axis name font size.
+     * @default 0.28
+     */
+    labelFontSize?: number;
+    /**
+     * Space between the outer ring and each axis name, which is anchored by its side facing the
+     * chart.
+     * @default 0.12
+     */
+    labelGap?: number;
+    /** Colour of the grid rings and spokes. Defaults to the theme's grid colour. */
+    gridColor?: ColorInput;
+    /**
+     * Reveal, 0..1: grid and names first, then the series, which grow out of the centre
+     * (`reveal="grow"`) or are uncovered by a clockwise sweep (`"sweep"`).
+     * @default 1
+     * @see https://sophistry.dev/guides/chart-animation/#reveals
+     */
+    progress?: number;
+    reveal?: RadialReveal;
+    /**
+     * How each polygon runs between vertices: `"linear"` straight edges or `"catmull-rom"` a smooth
+     * closed spline. The grid stays polygonal.
+     * @default "linear"
+     */
+    curve?: ClosedCurveKind;
+    /**
+     * Fraction of the series' reveal spent staggering polygon after polygon in data order, 0..0.95.
+     * @default 0
+     */
+    stagger?: number;
+    /**
+     * The order `stagger` and `enterStagger` take. See {@link StaggerOrder}.
+     * @default "position"
+     */
+    staggerOrder?: StaggerOrder;
+    /**
+     * The data to transition to, matched to `data` by `key`: each vertex moves along its axis to
+     * its new value. Axes are joined by name (`axisLabels`/`toAxisLabels`), else by position; axes
+     * that come and go fold in and out. See {@link KeyedTransitionProps}.
+     * @see https://sophistry.dev/guides/chart-animation/#data-transitions
+     */
+    to?: readonly T[];
+    /** `to`'s axis names, one per value of each `to` group. Defaults to `axisLabels`. */
+    toAxisLabels?: readonly string[];
+    /** Paint order. */
+    zIndex?: number;
+    /** Set to false to hide the chart. */
+    visible?: boolean;
+}
+/**
+ * Props of {@link radarChart}: `axisValues` is required unless `data` is `number[][]`.
+ *
+ * @category Charts
+ */
+export type RadarChartProps<T> = RadarChartBaseProps<T> & RequiredUnless<T, readonly number[], "axisValues">;
+/**
+ * A radar (spider) chart: one polygon per series, its values on evenly spaced axes around a
+ * full turn, over a grid of rings and spokes. Draws in scene units; needs at least 3 axes.
+ * Pass `maxValue` when the data can change, so the scale stays fixed. The polygons are one
+ * path batch.
+ *
+ * @example
+ * ```ts
+ * import { radarChart } from "@sophistry/charts";
+ *
+ * radarChart.create({
+ * 	data: [
+ * 		{ team: "a", v: [3, 4, 5, 2] },
+ * 		{ team: "b", v: [4, 2, 3, 5] },
+ * 	],
+ * 	axisValues: "v",
+ * 	series: "team",
+ * 	axisLabels: ["Speed", "Power", "Range", "Cost"],
+ * });
+ * ```
+ *
+ * @see https://sophistry.dev/reference/chart-catalogue/#pie-polar-area-and-radar
+ * @category Charts
+ */
+export declare const radarChart: import("@sophistry/core").Definition<RadarChartBaseProps<any>, import("@sophistry/core/internal").CompositeNode<RadarChartBaseProps<any>>, keyof RadarChartBaseProps<any>>;
+//# sourceMappingURL=radar-chart.d.ts.map

package/dist/radial/radar-chart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radar-chart.d.ts","sourceRoot":"","sources":["../../src/radial/radar-chart.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EACX,UAAU,EAQV,MAAM,iBAAiB,CAAC;AAUzB,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAUhF,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AA2B9E,OAAO,KAAK,EAEX,oBAAoB,EACpB,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,MAAM,UAAU,CAAC;AAsBlB,uBAAuB;AACvB,MAAM,WAAW,mBAAmB,CAAC,CAAC,CACrC,SAAQ,oBAAoB,CAAC,CAAC,CAAC,EAC9B,WAAW;IACZ,uFAAuF;IACvF,IAAI,EAAE,SAAS,CAAC,EAAE,CAAC;IACnB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;IAC3C;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS,MAAM,EAAE,CAAC;IACzC,mDAAmD;IACnD,MAAM,CAAC,EAAE,KAAK,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAC7B;;;OAGG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAC1B,2FAA2F;IAC3F,KAAK,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IACxB;;;OAGG;IACH,MAAM,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IAC/B;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB;;;;OAIG;IACH,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;;;OAKG;IACH,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC;IAClB,qFAAqF;IACrF,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,mBAAmB;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sCAAsC;IACtC,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,mBAAmB,CAAC,CAAC,CAAC,GACtD,cAAc,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,EAAE,YAAY,CAAC,CAAC;AAwjBpD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,UAAU,4KA6FrB,CAAC"}

package/dist/radial/radial-bar-chart.d.ts

@@ -0,0 +1,117 @@
+/**
+ * `radialBarChart`: concentric ring bars, one per datum, the first outermost.
+ *
+ * Two path batches: the faint full-length tracks (one shared paint, faded in
+ * together) and the value arcs (each its own fill; hover, taps, tooltips
+ * and accessible names per ring through `event.item` and `itemLabel`). Ring
+ * names stay `label` nodes.
+ */
+import type { ColorInput } from "@sophistry/core";
+import type { BandKey, Point } from "@sophistry/core/geometry";
+import type { Channel, ColorChannel, RequiredUnless } from "../data/channels";
+import type { TooltipSpec } from "../tooltip";
+/** @category Charts */
+export interface RadialBarChartBaseProps<T> {
+    /** One ring per datum, the first outermost. */
+    data: readonly T[];
+    /**
+     * The ring's value. Defaults to the datum when `data` is `number[]`; required otherwise.
+     * Negative and non-finite values count as 0 (an empty ring).
+     */
+    value?: Channel<T, number>;
+    /** The ring's name, written at its start. */
+    label?: Channel<T, string>;
+    /**
+     * The value that fills a ring's whole `sweep`; larger values are drawn full. Defaults to the
+     * greatest value.
+     */
+    maxValue?: number;
+    /** Centre of the chart. Defaults to the origin. */
+    center?: Point;
+    /**
+     * Outer radius of the outermost ring.
+     * @default 1
+     */
+    radius?: number;
+    /** Inner radius of the innermost ring. Defaults to 0.3 × `radius`. */
+    innerRadius?: number;
+    /** Gap between rings. Defaults to a quarter of a ring's width. */
+    ringGap?: number;
+    /**
+     * Radians a ring of `maxValue` turns through, clockwise from 12 o'clock. The default, 270°,
+     * leaves the top-left quadrant for labels.
+     * @default 3 * Math.PI / 2
+     */
+    sweep?: number;
+    /**
+     * The category of each ring: colours rings through the chart's shared colour scale and legend.
+     * `color` and `colors` win.
+     */
+    series?: Channel<T, BandKey>;
+    /** One colour for every ring, or `(d, i) => colour`. Wins over `colors` and `series`. */
+    color?: ColorChannel<T>;
+    /**
+     * Colours cycled across the rings by index. Wins over `series`. Defaults to the `series`
+     * colours, else the theme's categorical colours.
+     */
+    colors?: readonly ColorInput[];
+    /**
+     * Colour of the faint full-length track behind each ring. Defaults to the theme's grid colour.
+     */
+    trackColor?: ColorInput;
+    /**
+     * Write each ring's `label` at its start.
+     * @default true
+     */
+    labels?: boolean;
+    /** Label font size. Defaults to 0.7 × a ring's width, at most 0.26. */
+    labelFontSize?: number;
+    /**
+     * Reveal, 0..1: tracks and labels fade in, then each ring sweeps clockwise, outermost first.
+     * @default 1
+     * @see https://sophistry.dev/guides/chart-animation/#reveals
+     */
+    progress?: number;
+    /**
+     * Fraction of the bars' reveal spent staggering ring after ring, outer to inner, 0..0.95.
+     * @default 0.3
+     */
+    stagger?: number;
+    /** Hover tooltip: `true` for "label: value", or `(d, i) => string`. */
+    tooltip?: TooltipSpec<T>;
+    /** Paint order; higher draws later. */
+    zIndex?: number;
+    visible?: boolean;
+}
+/**
+ * Props of {@link radialBarChart}: `value` is required unless `data` is `number[]`.
+ *
+ * @category Charts
+ */
+export type RadialBarChartProps<T> = RadialBarChartBaseProps<T> & RequiredUnless<T, number, "value">;
+/**
+ * Concentric ring bars: a bar chart bent round a centre, one ring per datum (the first
+ * outermost), each arc its value over `maxValue`. Outer rings are longer at the same value, so
+ * compare angles, not lengths. Draws in scene units; needs no `chart`.
+ *
+ * @example
+ * ```ts
+ * import { radialBarChart } from "@sophistry/charts";
+ *
+ * radialBarChart.create({
+ * 	data: [
+ * 		{ goal: "Move", pct: 80 },
+ * 		{ goal: "Stand", pct: 50 },
+ * 	],
+ * 	value: "pct",
+ * 	label: "goal",
+ * 	maxValue: 100,
+ * 	tooltip: true,
+ * });
+ * ```
+ *
+ * @see https://sophistry.dev/reference/chart-catalogue/#gauges-bullets-waffles-mosaics-and-radial-bars
+ * @category Charts
+ */
+export declare const radialBarChart: import("@sophistry/core").Definition<RadialBarChartBaseProps<any>, import("@sophistry/core/internal").CompositeNode<RadialBarChartBaseProps<any>>, keyof RadialBarChartBaseProps<any>>;
+//# sourceMappingURL=radial-bar-chart.d.ts.map

package/dist/radial/radial-bar-chart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radial-bar-chart.d.ts","sourceRoot":"","sources":["../../src/radial/radial-bar-chart.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACX,UAAU,EAMV,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAW/D,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAY9E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAsB9C,uBAAuB;AACvB,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACzC,+CAA+C;IAC/C,IAAI,EAAE,SAAS,CAAC,EAAE,CAAC;IACnB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IAC3B,6CAA6C;IAC7C,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mDAAmD;IACnD,MAAM,CAAC,EAAE,KAAK,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAC7B,yFAAyF;IACzF,KAAK,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IACxB;;;OAGG;IACH,MAAM,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IAC/B;;OAEG;IACH,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,uEAAuE;IACvE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uEAAuE;IACvE,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACzB,uCAAuC;IACvC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,uBAAuB,CAAC,CAAC,CAAC,GAC9D,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AA2PpC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,cAAc,wLAwDzB,CAAC"}

package/dist/radial/shared.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Helpers shared by the radial charts (pie, polar area, radar, radial bars,
+ * gauge, chord, waffle): wedge outlines as path batch items, a per-key item
+ * cache (so an unchanged wedge keeps its prepared outline), keyed label
+ * lists, the far end's colour scale across a keyed transition, and the
+ * standalone tooltip state. Internal to the family.
+ */
+import type { CompositeContext, LabelProps, PathBatchItem, SceneNode } from "@sophistry/core";
+import type { Theme } from "@sophistry/core/themes";
+import type { OrdinalColorScale } from "../math/ordinal";
+import type { Category } from "../series";
+import type { TooltipState } from "../tooltip";
+/** Smallest sweep worth drawing, in radians: what `sector` and `annularSector` skip. */
+export declare const NO_SWEEP = 1e-9;
+/** What a wedge's outline is made from. */
+export interface WedgeShape {
+    cx: number;
+    cy: number;
+    /** 0 for a plain pie slice (`sector`), else a ring slice (`annularSector`). */
+    innerRadius: number;
+    outerRadius: number;
+    startAngle: number;
+    /** Signed sweep, radians; positive is counter-clockwise. */
+    angle: number;
+}
+/**
+ * A wedge as a path batch item: the same native curve geometry `sector` (no
+ * hole) or `annularSector` (a hole) build, so each item outlines exactly
+ * what the per-datum shape does. Undefined when the sweep is too small
+ * to draw (as those shapes draw nothing).
+ *
+ * @param annular - Draw a ring slice even when `innerRadius` is 0.
+ */
+export declare function wedgeItem(shape: WedgeShape, paints: Omit<PathBatchItem, "closed" | "polylines" | "curvePaths">, annular?: boolean): PathBatchItem | undefined;
+/**
+ * A per-key cache of path batch items: hands back last update's item while
+ * its inputs are equal (shallowly), so the batch reuses its prepared outline.
+ * Call `sweep()` after an update to forget keys that were not asked for.
+ */
+export declare function createItemCache<I>(): {
+    get(key: unknown, inputs: readonly unknown[], make: () => I): I;
+    sweep(): void;
+};
+/** One label of a keyed list: its key and the label's props. */
+export interface KeyedLabel {
+    key: unknown;
+    props: LabelProps;
+}
+/**
+ * Keyed `label` nodes for one list (`slot`): a node per key, created once
+ * and updated in place (equal values are no-ops on the node), disposed when
+ * its key leaves.
+ */
+export declare function labelList<P>(ctx: CompositeContext<P>, slot: string, labels: readonly KeyedLabel[]): SceneNode[];
+/**
+ * The colour scale `to`'s series colour through, across a keyed transition:
+ * the chart's shared scale inside a chart (`own`), else one over `to`'s own
+ * categories, as its plain chart has. Call once, in
+ * `setup`.
+ */
+export declare function createFarScale(): (inChart: boolean, toOf: readonly Category[] | undefined, own: OrdinalColorScale, theme: Theme) => OrdinalColorScale;
+/**
+ * The tooltip a standalone radial chart shows through: the enclosing
+ * chart's, else its own. Call once,
+ * in `setup`, and read the result in each `update`.
+ *
+ * Outside a chart the state is kept (handlers, accessible names, the item
+ * walked by the keys) and `overlay(ctx)` returns the panel drawing it, a
+ * {@link tooltipOverlay} bound to the scene's pointer and view: append it to the composite's children. Inside a
+ * chart it returns nothing, the frame's overlay draws the tooltip.
+ */
+export declare function createOwnTooltip(): OwnTooltip;
+/** What {@link createOwnTooltip} returns: the state, and its standalone panel. */
+export interface OwnTooltip {
+    <P>(ctx: CompositeContext<P>): TooltipState;
+    /** The panel to append to the children outside a chart; empty inside one. */
+    overlay<P>(ctx: CompositeContext<P>): SceneNode[];
+}
+//# sourceMappingURL=shared.d.ts.map