@dou-ui/chart 0.0.0-stage → 0.1.0-alpha.0

package/dist/types/core/pattern.d.ts

@@ -0,0 +1,14 @@
+import type { Painter, Rect } from './painter';
+export type ChartPattern = 'diagonal' | 'dots' | 'crosshatch' | 'horizontal' | 'backslash' | 'grid' | 'vertical';
+/** The patterns in the order series and slices take them. */
+export declare const CHART_PATTERNS: readonly ChartPattern[];
+/**
+ * Draws `pattern` over `box` in `ink`, clipped to the current path: call
+ * it right after filling a shape, while its path is still the current one.
+ */
+export declare function fillPattern(painter: Painter, pattern: ChartPattern, box: Rect, ink: string, alpha?: number): void;
+/** The same pattern for a legend swatch, as a CSS background image and its size. */
+export declare function patternCss(pattern: ChartPattern, ink: string): {
+    image: string;
+    size?: string;
+};

package/dist/types/core/pie.d.ts

@@ -0,0 +1,66 @@
+import { type ChartAccessor, type ChartData } from './data';
+import type { Painter } from './painter';
+import { type ChartPattern } from './pattern';
+/** A slice of a pie, with its angles in radians clockwise from 12 o'clock. */
+export interface PieSlice {
+    /** The row's index. */
+    index: number;
+    label: string;
+    value: number;
+    /** Its own color, if the pie reads one. */
+    color?: string;
+    /** Its part of the whole, 0 to 1; 0 when hidden. */
+    share: number;
+    /** Turned off in the legend: it keeps its color, but takes no room. */
+    hidden: boolean;
+    start: number;
+    end: number;
+    /**
+     * How much of its ring it fills, 0 to 1: 1, but for a rose, whose
+     * slices share the turn evenly and fill out by their values.
+     */
+    reach: number;
+}
+/**
+ * How far out a slice reaches, from a hole of `inner` px to `radius` px:
+ * a rose's slice by area, so twice the value covers twice the ink.
+ */
+export declare function sliceOuter(slice: Pick<PieSlice, 'reach'>, inner: number, radius: number): number;
+/** The part of the turn a pie takes, and whether it is a rose. */
+export interface PieShape {
+    /** Where the slices start and end, in radians clockwise from 12 o'clock. */
+    start?: number;
+    end?: number;
+    /** Each slice the same angle, its area (not its angle) by its value. */
+    rose?: boolean;
+}
+/**
+ * The slices of `rows`: one per row with a value above 0, in the order
+ * given, going round clockwise from the top. Slices named in `hidden`
+ * are kept, with no room, so they keep their place and color.
+ */
+export declare function pieSlices(rows: ChartData, value: ChartAccessor, label: ChartAccessor | undefined, color?: ChartAccessor, hidden?: readonly string[], shape?: PieShape): PieSlice[];
+/** How much of a series or slice shows while another is brought forward. */
+export declare const FADED = 0.24;
+/**
+ * Draws the slices around `cx, cy`, from `inner` (0 for a pie) to
+ * `radius`, with a gap of the chart's surface color between them. With
+ * `focus`, the other slices are faded; `sweep` (0 to 1) draws only that
+ * much of the way round, for the pie to come in.
+ */
+export declare function drawPie(painter: Painter, slices: PieSlice[], colors: string[], { cx, cy, radius, inner, surface, focus, fade, sweep, from, patterns, }: {
+    cx: number;
+    cy: number;
+    radius: number;
+    inner: number;
+    surface: string;
+    /** The `index` of the slice to bring forward. */
+    focus?: number;
+    /** How much the other slices show. */
+    fade?: number;
+    sweep?: number;
+    /** Where the slices start: coming in, they sweep round from there. */
+    from?: number;
+    /** The pattern over each slice, by its `index`. */
+    patterns?: Array<ChartPattern | null>;
+}): void;

package/dist/types/core/radar.d.ts

@@ -0,0 +1,12 @@
+import type { ChartSeriesKind } from './series';
+export interface RadarStyle {
+    /** Dots on the corners: `true`, `false`, or (the default) when there are few. */
+    dots?: boolean;
+    /** The width of the outline, in px. */
+    lineWidth?: number;
+}
+/** The angle of spoke `index` of `count`, clockwise from 12 o'clock. */
+export declare function spokeAngle(index: number, count: number): number;
+/** The spoke nearest the angle `angle` (clockwise from 12 o'clock), of `count`. */
+export declare function nearestSpoke(angle: number, count: number): number;
+export declare const radarKind: ChartSeriesKind<RadarStyle>;

package/dist/types/core/scale.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Scales turn data values into pixels and back. They are plain objects
+ * with the mapping folded into two numbers, so `map` costs a multiply and
+ * an add: it runs once per drawn point.
+ */
+export type ScaleKind = 'linear' | 'log' | 'time' | 'category';
+export interface Scale {
+    kind: ScaleKind;
+    /** The values at the two ends, after rounding to nice numbers. */
+    domain: [number, number];
+    /** The pixels the two ends of `domain` land on. */
+    range: [number, number];
+    map(value: number): number;
+    invert(pixel: number): number;
+    /** For `category`: the room each category gets, in px. 0 otherwise. */
+    step: number;
+    /** For `category`: the categories. */
+    categories: string[];
+    /** For all but `log`: `map(v)` is `v * k + b`, for loops that can't afford a call per point. */
+    k: number;
+    b: number;
+}
+/**
+ * The step of 1, 2 or 5 times a power of ten that gives closest to
+ * `count` steps across `span` (rounding on a log scale, so it may give a
+ * few more or fewer).
+ */
+export declare function niceStep(span: number, count: number): number;
+/** The next nice step up: 1 → 2 → 5 → 10. */
+export declare function nextNiceStep(step: number): number;
+/** How many decimals tell the ticks of `step` apart. */
+export declare function stepDecimals(step: number): number;
+/**
+ * A domain wide enough to show `[min, max]`: an empty span is widened, and
+ * with `nice` the ends are rounded out to the tick step for about `count` ticks.
+ */
+export declare function linearDomain(min: number, max: number, { count, nice }?: {
+    count?: number;
+    nice?: boolean;
+}): [number, number];
+/** Ticks at the multiples of a nice step inside `[lo, hi]`, about `count` of them. */
+export declare function linearTicks(lo: number, hi: number, count: number): number[];
+export declare function linearScale(domain: [number, number], range: [number, number], kind?: 'linear' | 'time'): Scale;
+/** Rounds out to whole powers of ten; values at or below 0 can't be shown and are left out. */
+export declare function logDomain(min: number, max: number): [number, number];
+export declare function logTicks(lo: number, hi: number, count: number): number[];
+export declare function logScale(domain: [number, number], range: [number, number]): Scale;
+/**
+ * Categories side by side, each in the middle of its own step. `map(i)` is
+ * the middle of category `i`; `domain` is `[-0.5, n - 0.5]` so that a
+ * category's step runs from `map(i - 0.5)` to `map(i + 0.5)`.
+ */
+export declare function categoryScale(categories: string[], range: [number, number]): Scale;
+/** Every `every`-th category index, starting from the first. */
+export declare function categoryTicks(count: number, every?: number): number[];
+/**
+ * The pixel that areas and bars grow from: 0, or the nearer end when 0 is
+ * off the axis (always the start on a log axis).
+ */
+export declare function baseline(scale: Scale): number;

package/dist/types/core/scatter.d.ts

@@ -0,0 +1,16 @@
+import { type ChartAccessor } from './data';
+import type { Painter } from './painter';
+import type { ChartHit, ChartSeries, ChartSeriesKind, ChartView } from './series';
+export interface ScatterStyle {
+    /** The bubble size of each row; the area of a bubble grows with it. */
+    size?: ChartAccessor;
+    /** Dot radius in px; with `size`, the radius of the largest bubble. */
+    radius?: number;
+}
+export declare function drawScatter(painter: Painter, series: ChartSeries<ScatterStyle>, view: ChartView): void;
+/**
+ * The point under `(px, py)`: the bubble it is inside (the smallest, which
+ * is drawn on top), or the dot nearest to it within a finger's reach.
+ */
+export declare function hitScatter(series: ChartSeries<ScatterStyle>, view: ChartView, px: number, py: number): ChartHit | null;
+export declare const scatterKind: ChartSeriesKind<ScatterStyle>;

package/dist/types/core/series.d.ts

@@ -0,0 +1,228 @@
+import type { Tone } from 'dou-ui';
+import type { ChartAccessor, ChartData, XColumn } from './data';
+import type { ChartPattern } from './pattern';
+import type { Painter, Rect } from './painter';
+import type { Scale } from './scale';
+/** The y axis a series is measured on. */
+/** The value axis a series is measured on: `y`, or `y2` for a second kind of values. */
+export type ChartValueAxis = 'y' | 'y2';
+/** What every series accepts. */
+export interface ChartSeriesProps {
+    /** The value of each row: a key of the row or a function of it. */
+    y: ChartAccessor;
+    /** Shown in the legend and the tooltip. Defaults to `y` when that is a key. */
+    name?: string;
+    /** Rows of this series alone; defaults to the chart's `data`. */
+    data?: ChartData;
+    /** The x of each row of this series' own `data`; defaults to the chart's `x`. */
+    x?: ChartAccessor;
+    /**
+     * Any CSS color. Defaults to the next color of the chart palette. Kinds
+     * that draw each point on its own (bars, scatter) also take a function of
+     * the row giving that point's color: a CSS color or a tone, `undefined`
+     * for the series' color. Its results are in `series.colors`.
+     */
+    color?: string | ((row: any, index: number) => string | undefined);
+    /** A tone, for when the color means something (`danger` for errors). */
+    tone?: Tone;
+    /** The value axis to measure on: `y2` is a second one, on the right (on the top when horizontal). */
+    axis?: ChartValueAxis;
+}
+/** A series as it is drawn: its data read into columns and its color worked out. */
+export interface ChartSeries<P = Record<string, unknown>> {
+    /** Stable for the series' lifetime: its place among all series, hidden or not. */
+    index: number;
+    kind: ChartSeriesKind<any>;
+    props: ChartSeriesProps & P;
+    name: string;
+    /** The rows the series reads: its own `data`, or the chart's. */
+    rows: ChartData;
+    /** The color as a CSS color the canvas understands. */
+    color: string;
+    /**
+     * Colors of single points or bars, by row, for a series whose `color`
+     * is a function (bars, scatter); `undefined` where the row takes `color`.
+     */
+    colors?: Array<string | undefined> | null;
+    axis: ChartValueAxis;
+    x: XColumn;
+    /** The values as given. */
+    y: Float64Array;
+    /** Where the series is drawn: `y`, or the top of its slice of a stack. */
+    top: Float64Array;
+    /** The bottom of its slice of a stack; `null` when not stacked. */
+    base: Float64Array | null;
+    /**
+     * For a stacked series: how far the whole stack reaches at each x, up
+     * (positives) and down (negatives). A slice whose `top` is there is the
+     * outermost one.
+     */
+    stackEnds: {
+        up: Float64Array;
+        down: Float64Array;
+    } | null;
+    /** For series that share the room of each x (bars): which part is theirs. */
+    slot: {
+        index: number;
+        count: number;
+    } | null;
+    /** The pattern drawn over its fill, if any (the chart's `patterns`, or its own `pattern`). */
+    pattern?: ChartPattern | null;
+    /**
+     * What the kind's `prepare` gave back for this data; `undefined` until
+     * it has run, so `draw` and `hit` must work without it.
+     */
+    prepared?: unknown;
+}
+/** What a series draws with. */
+export interface ChartView {
+    /** The x scale. With `horizontal`, it runs down the left side. */
+    x: Scale;
+    /** The value scale. With `horizontal`, it runs along the bottom. */
+    y: Scale;
+    /** Whether x runs down and values run across: `map` of `x` gives a top, of `y` a left. */
+    horizontal: boolean;
+    /** The room each x value gets along the x axis, in px: a category's width, or the closest two x apart. */
+    band: number;
+    /** Where a value at `x` lands, as `[left, top]` in CSS px, whichever way the chart runs. */
+    point(x: number, value: number): [number, number];
+    /** The plot area, in CSS px. */
+    plot: Rect;
+    /** Device pixels per CSS px. */
+    dpr: number;
+    /**
+     * Drawing into an SVG (an export, the server's image): shapes only, no
+     * images of another canvas.
+     */
+    vector?: boolean;
+    /** The resolved colors of the chart. */
+    colors: ChartColors;
+    /**
+     * For a radar: its center and radius, and how many spokes. `point`
+     * then takes a spoke (the category's index) and a value.
+     */
+    polar?: {
+        cx: number;
+        cy: number;
+        radius: number;
+        count: number;
+    };
+}
+export interface ChartColors {
+    /** What the chart sits on; rings around dots, gaps between slices. */
+    surface: string;
+    grid: string;
+    baseline: string;
+}
+/** A kind of series: how it widens the axes and how it draws. */
+export interface ChartSeriesKind<P = Record<string, unknown>> {
+    /** What kind of series it is, in class names (`is-bar`): the legend draws its swatch from it. */
+    type: string;
+    /** Whether the value axis must reach 0 (areas and bars grow from it). */
+    zero?: boolean;
+    /**
+     * Whether the series places its rows by category on the value axis too
+     * (a heatmap): `y` names a category, `value` gives each cell's value.
+     * The value axis then lists the categories, the first at the top; `y`
+     * holds the values and `top` the categories' places.
+     */
+    categoryY?: boolean;
+    /**
+     * Whether the series is drawn round a center (a radar): a spoke for each
+     * category, values out from the center. It can't share a chart with
+     * series drawn on axes.
+     */
+    polar?: boolean;
+    /**
+     * Whether the series is a funnel: its rows are stages, one bar under
+     * another, without axes. It is drawn alone, as a pie is.
+     */
+    funnel?: boolean;
+    /**
+     * Whether the series is a waterfall: each value a change, drawn from the
+     * running total before it (`base`) to the one after (`top`); rows its
+     * `total` marks are drawn from 0 to the running total.
+     */
+    waterfall?: boolean;
+    /**
+     * Whether the series is a box plot: `y` gives each row a group of values,
+     * summed up in a box; `y` holds the medians, and `base` and `top` the
+     * smallest and largest values, so the axis reaches them.
+     */
+    box?: boolean;
+    /** Whether series of this kind can stack (`stack` prop). */
+    stackable?: boolean;
+    /**
+     * Whether series of this kind share the room of each x side by side
+     * (bars): each gets a `slot`, and the x axis leaves half a band of room
+     * at both ends.
+     */
+    band?: boolean;
+    /**
+     * Room the series needs around each point, in px, for marks larger than
+     * a dot (bubbles): the axes are widened so they fit inside the plot.
+     */
+    inset?(series: Pick<ChartSeries<P>, 'props' | 'rows' | 'x' | 'y'>): number;
+    draw(painter: Painter, series: ChartSeries<P>, view: ChartView): void;
+    /**
+     * What the tooltip shows by default: every series at the x under the
+     * pointer (`axis`, the default), or the one point under it (`item`,
+     * for scatters).
+     */
+    tooltip?: 'axis' | 'item';
+    /**
+     * The point under `(px, py)` for an `item` tooltip, and the radius of its
+     * mark. By default, the nearest point within 12px.
+     */
+    hit?(series: ChartSeries<P>, view: ChartView, px: number, py: number): ChartHit | null;
+    /**
+     * Work done ahead, once the data has stayed the same a moment and the
+     * page is idle, so `hit` (or `draw`) can be quicker: building an index,
+     * say. What it gives back is kept as `series.prepared`. Not run for data
+     * replaced many times a second (live data).
+     */
+    prepare?(series: ChartSeries<P>): unknown;
+    /**
+     * The tooltip's title for row `row`, in place of its x as the axis
+     * writes it (`text`): a histogram's bin, from its start to its end.
+     */
+    xTitle?(series: ChartSeries<P>, row: number, text: (x: number) => string): string;
+    /**
+     * For a `band` series, how wide one band is in x's units, in place of
+     * the smallest gap between its x values: a histogram's bin width, which
+     * holds with only one bin.
+     */
+    xStep?(series: ChartSeries<P>): number;
+    /**
+     * Where the series' data labels go (`labels` prop): a point and the side
+     * of it the text takes, for each row on screen worth a label. The chart
+     * writes the text, and leaves out labels that cover others.
+     */
+    labels?(series: ChartSeries<P>, view: ChartView): ChartLabelAnchor[];
+}
+/** Where a data label goes. */
+export interface ChartLabelAnchor {
+    /** The row's index in the series' rows. */
+    index: number;
+    /** The point the label is beside, in CSS px. */
+    at: [number, number];
+    /** Which side of `at` the text goes; `center` puts it on `at`, inside `box`. */
+    side: 'top' | 'bottom' | 'left' | 'right' | 'center';
+    /** For `center`: the shape the text must fit in (a bar), and its color. */
+    box?: Rect & {
+        color: string;
+    };
+    /**
+     * The most room the label may take across its side, in px: its width
+     * above or below the point, its height beside it. A bar's label stays
+     * within the room of its bar.
+     */
+    room?: number;
+}
+/** A point found under the pointer. */
+export interface ChartHit {
+    /** The row's index in the series' rows. */
+    index: number;
+    /** The radius of its mark in px, for the ring that shows it. */
+    radius: number;
+}

package/dist/types/core/svg.d.ts

@@ -0,0 +1,63 @@
+import type { Painter } from './painter';
+/** A number with at most two decimals, short in the markup. */
+export declare const num: (value: number) => string;
+/** Text made safe to put in markup, as content or in an attribute. */
+export declare const escapeXml: (text: string) => string;
+/** `name="value"` for a color, or a style when SVG attributes can't take it (`var(…)`, `color-mix(…)`). */
+export declare function paintAttribute(name: 'fill' | 'stroke' | 'stop-color', color: string): string;
+export declare class SvgPainter implements Painter {
+    private prefix;
+    private color;
+    fillStyle: string | CanvasGradient | CanvasPattern;
+    strokeStyle: string | CanvasGradient | CanvasPattern;
+    lineWidth: number;
+    lineJoin: CanvasLineJoin;
+    lineCap: CanvasLineCap;
+    globalAlpha: number;
+    private dash;
+    private clipId;
+    private states;
+    private path;
+    /** The current point, and where the current subpath starts; `NaN` when there is none. */
+    private cx;
+    private cy;
+    private sx;
+    private sy;
+    private body;
+    private defs;
+    private clips;
+    private ids;
+    /**
+     * `prefix` starts every id the markup gives, so two SVGs in one page
+     * don't share them; `color` turns a color into one the SVG's reader
+     * understands.
+     */
+    constructor(prefix: string, color?: (css: string) => string);
+    /** An id of its own in this SVG, for something drawn as raw markup (a gradient). */
+    id(name: string): string;
+    save(): void;
+    restore(): void;
+    beginPath(): void;
+    closePath(): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    bezierCurveTo(c1x: number, c1y: number, c2x: number, c2y: number, x: number, y: number): void;
+    rect(x: number, y: number, width: number, height: number): void;
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
+    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+    setLineDash(segments: Iterable<number>): void;
+    fill(rule?: CanvasFillRule | Path2D): void;
+    stroke(): void;
+    clip(): void;
+    drawImage(image: CanvasImageSource, ...args: number[]): void;
+    /** Draws what `draw` paints as one layer, `alpha` see-through as a whole. */
+    layer(alpha: number, draw: () => void): void;
+    /** Adds markup as it is, for what the painter can't draw (text). */
+    raw(markup: string): void;
+    /** The clip and see-through every shape takes from the state. */
+    private common;
+    /** What was drawn, as the inside of an `<svg>`. */
+    markup(): string;
+}
+/** Whether a painter writes SVG: it then draws layers and text itself. */
+export declare const isSvg: (painter: unknown) => painter is SvgPainter;

package/dist/types/core/sync.d.ts

@@ -0,0 +1,8 @@
+/** An x as charts of a group share it; `null` when the pointer left. */
+export type SharedX = string | number | null;
+type Listener = (x: SharedX) => void;
+/** Listens to the x shown in `group`; gives back how to stop. */
+export declare function joinGroup(group: string, listener: Listener): () => void;
+/** Shows `x` in every chart of `group` but the one telling (`from`). */
+export declare function tellGroup(group: string, x: SharedX, from: Listener): void;
+export {};

package/dist/types/core/time.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Ticks on a time axis, at round points of local time: whole minutes,
+ * midnights, the first of a month. The step is the smallest one that
+ * gives no more than the wanted number of ticks.
+ */
+export type TimeUnit = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year';
+export interface TimeInterval {
+    unit: TimeUnit;
+    every: number;
+}
+/** The smallest interval that gives at most `count` ticks across `span` ms. */
+export declare function timeInterval(span: number, count: number): TimeInterval;
+/** The start of the `unit` that `time` falls in (weeks start on Monday). */
+export declare function floorTime(time: number, unit: TimeUnit): Date;
+/** The ticks of `interval` from `lo` to `hi` (ms), both ends included when they fall on one. */
+export declare function timeTicks(lo: number, hi: number, interval: TimeInterval): number[];
+/** The next unit up, whose boundaries a tick label marks with more context. */
+export declare function parentUnit(unit: TimeUnit): TimeUnit | null;
+/** Whether `time` is the very start of a `unit`. */
+export declare function startsUnit(time: number, unit: TimeUnit): boolean;

package/dist/types/core/tree.d.ts

@@ -0,0 +1,84 @@
+import { type ChartAccessor, type ChartRow } from './data';
+import type { Painter, Rect } from './painter';
+export interface TreeNode {
+    /** Its place in `nodes`, in the order the tree is walked (parents first). */
+    index: number;
+    name: string;
+    /** Its own value (a leaf's), or the sum of its children's. */
+    value: number;
+    /** 1 for the top level: the root, which holds the whole, is 0. */
+    depth: number;
+    parent: TreeNode | null;
+    children: TreeNode[];
+    /** The row it was read from; the root has none. */
+    row: ChartRow | null;
+    /** Its row's place among its siblings' rows, as accessors are given it. */
+    place: number;
+    /** The place of its top-level node among the top level, which picks its color. */
+    group: number;
+    /** A treemap's rectangle, or a sunburst's arc (angles and radii). */
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+export interface TreeAccessors {
+    label: ChartAccessor;
+    value: ChartAccessor;
+    children: ChartAccessor;
+}
+/** The tree read from nested rows, and its nodes walked parents first; nodes without value are left out. */
+export declare function buildTree(data: readonly ChartRow[] | undefined, { label, value, children }: TreeAccessors): {
+    root: TreeNode;
+    nodes: TreeNode[];
+};
+/** The names from the top level down to `node`. */
+export declare function treePath(node: TreeNode): string[];
+/** Room above a group's children for its name, in px. */
+export declare const TREE_HEADER = 20;
+/**
+ * Lays the treemap out in `rect`: each node's rectangle as near a square
+ * as can be (the squarified layout), largest first, children inside their
+ * group below its header.
+ */
+export declare function layoutTreemap(root: TreeNode, rect: Rect): void;
+/** Whether a treemap group has room for its header (see `layoutTreemap`). */
+export declare function hasHeader(node: TreeNode): boolean;
+/** The deepest node of a treemap under `(px, py)`. */
+export declare function treemapAt(root: TreeNode, px: number, py: number): TreeNode | null;
+/**
+ * Draws a treemap: a leaf filled with its color, a group a light wash of
+ * it under its children. `focus` (a node's index) is ringed.
+ */
+export declare function drawTreemap(painter: Painter, nodes: TreeNode[], colors: string[], { surface, ring, focus, t, }: {
+    surface: string;
+    ring: string;
+    focus?: number;
+    t?: number;
+}): void;
+/** Rings a treemap's node: the one under the pointer or picked with the keys. */
+export declare function ringTreemap(painter: Painter, node: TreeNode | undefined, ring: string): void;
+/**
+ * Lays a sunburst out round `(cx, cy)`: the top level in the ring just out
+ * of the hole (`inner`), each level a ring further out to `radius`; each
+ * node's arc a share of its parent's as its value is of the parent's.
+ * Angles run clockwise from 12 o'clock.
+ */
+export declare function layoutSunburst(root: TreeNode, inner: number, radius: number): void;
+/** The node of a sunburst under the angle `angle` (clockwise from 12 o'clock) and radius `r`. */
+export declare function sunburstAt(root: TreeNode, angle: number, r: number): TreeNode | null;
+/**
+ * Draws a sunburst round `(cx, cy)`, sweeping in with `sweep` (0 to 1).
+ * Nodes other than `focus`, its ancestors and its descendants are faded.
+ */
+/** How much of a sunburst shows off the branch pointed at. */
+export declare const SUNBURST_FADE = 0.4;
+/** A node with its ancestors and all its descendants: what stays lit when it is pointed at. */
+export declare function sunburstBranch(node: TreeNode): TreeNode[];
+export declare function drawSunburst(painter: Painter, nodes: TreeNode[], colors: string[], { cx, cy, surface, focus, sweep, }: {
+    cx: number;
+    cy: number;
+    surface: string;
+    focus?: number;
+    sweep?: number;
+}): void;

package/dist/types/core/warn.d.ts

@@ -0,0 +1,4 @@
+/** A warning in development, once per kind of mistake. */
+export declare function warnOnce(key: string, text: string): void;
+/** Forgets what was warned about, so a test sees each warning afresh. */
+export declare function forgetWarnings(): void;

package/dist/types/core/waterfall.d.ts

@@ -0,0 +1,24 @@
+import { type ChartAccessor, type ChartData } from './data';
+import type { ChartSeries, ChartSeriesKind } from './series';
+export interface WaterfallStyle {
+    /** Whether a row is a total: a key of the row or a function of it. */
+    total?: ChartAccessor;
+    /** Corner radius of the bars, in px. */
+    radius?: number;
+    /** Lines from each bar to the next, at the total they share. */
+    connectors?: boolean;
+    labelPosition?: 'outside' | 'inside';
+}
+/**
+ * The bars of a waterfall: where each starts (`base`) and ends (`top`), and
+ * its value (`y`): the change, or for a total row, the running total. A
+ * row without a value is left out and changes nothing.
+ */
+export declare function waterfallSteps(rows: ChartData, changes: Float64Array, total: ChartAccessor | undefined): {
+    y: Float64Array;
+    top: Float64Array;
+    base: Float64Array;
+};
+/** Whether row `i` of a waterfall is a total. */
+export declare function isTotal(series: Pick<ChartSeries<WaterfallStyle>, 'props' | 'rows'>, i: number): boolean;
+export declare const waterfallKind: ChartSeriesKind<WaterfallStyle>;

package/dist/types/core/window.d.ts

@@ -0,0 +1,36 @@
+import { type XKind } from './data';
+import type { ChartTickValue } from './layout';
+import type { Scale } from './scale';
+export type Window = [number, number];
+/** Turns a value as given (a category, a date, a number) into the scale's number; `NaN` if it can't be. */
+export declare function valueToNumber(value: ChartTickValue, kind: XKind, categories: string[]): number;
+/** The value as given for a scale number: the category, a `Date`, or the number. */
+export declare function numberToValue(value: number, kind: XKind, categories: string[]): ChartTickValue;
+/**
+ * The window of an interval as given; categories take their whole step,
+ * from half a step before the first to half after the last. `null` for
+ * none, or one that can't be read.
+ */
+export declare function intervalToWindow(interval: readonly [ChartTickValue, ChartTickValue] | null | undefined, kind: XKind, categories: string[]): Window | null;
+/** The interval of a window: for categories, the first and last mostly in it. */
+export declare function windowToInterval(window: Window, kind: XKind, categories: string[]): [ChartTickValue, ChartTickValue];
+/** A window on categories moved to whole steps, keeping at least one. */
+export declare function snapCategories([a, b]: Window): Window;
+/** Numbers a scale is even in: the log of a log scale's values. */
+export interface Units {
+    to: (value: number) => number;
+    from: (unit: number) => number;
+}
+export declare const unitsOf: (scale: Pick<Scale, "kind">) => Units;
+/**
+ * `window` kept inside `full`, at least `least` wide (in units): a window
+ * that runs over an end is moved back, not cut. `null` when it covers
+ * all of `full`.
+ */
+export declare function clampWindow(window: Window, full: Window, least: number, units?: Units): Window | null;
+/** The window `scale` shows with its range moved `by` px: dragging the plot by `-by`. */
+export declare function panWindow(scale: Scale, by: number): Window;
+/** The window `scale` shows zoomed by `factor` (below 1 is in) about the pixel `at`. */
+export declare function zoomWindow(scale: Scale, at: number, factor: number): Window;
+/** Whether `value` is at or between the ends of `window`. */
+export declare const within: (value: number, window: Window) => boolean;