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

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

@@ -0,0 +1,33 @@
+import { type TimeInterval, type TimeUnit } from './time';
+/**
+ * Formats the ticks of a number axis: as many decimals as the step needs,
+ * and in short form ("12万", "1.2M") once the numbers get long, with as
+ * many digits as it takes to tell the ticks apart. With `years`, whole
+ * numbers under 10000 go without separators, so 2019 doesn't read "2,019".
+ */
+export declare function numberTickFormat(locale: string, ticks: number[], { years }?: {
+    years?: boolean;
+}): (value: number) => string;
+/** Formats a value for reading in full (tooltips, the accessible summary). */
+export declare function numberFormatFull(locale: string): (value: number) => string;
+/**
+ * Formats the ticks of a time axis. Most ticks show only the unit they
+ * step by ("15日", "09:00"); the first one and the first in each bigger
+ * unit say more ("11月2日", "2026年1月"), so the axis reads without a legend.
+ * `previous` is the tick before, if any.
+ */
+export declare function timeTickFormat(locale: string, interval: TimeInterval): (value: number, previous?: number) => string;
+/**
+ * How precisely a point in time needs writing: as precise as the time
+ * itself (09:30 needs minutes), and as its neighbor is near (points 100ms
+ * apart need tenths of a second, even on a whole second). `digits` are
+ * the digits of a second, from 1 to 3.
+ */
+export declare function timePrecision(value: number, gap?: number): {
+    unit: "second" | "minute" | "day";
+    digits: 0 | 1 | 2 | 3;
+};
+/** Formats a point in time in full, as precise as `unit` (tooltips, the accessible summary). */
+export declare function timeFormatFull(locale: string, unit?: TimeUnit, 
+/** Digits of a second, for times less than a second apart. */
+digits?: 0 | 1 | 2 | 3): (value: number) => string;

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

@@ -0,0 +1,15 @@
+import type { ChartSeries, ChartSeriesKind, ChartView } from './series';
+export interface FunnelStyle {
+    /** Corner radius of the bars, in px. */
+    radius?: number;
+}
+/** How much of a stage's row its bar takes; the rest is the band to the next. */
+export declare const FUNNEL_BAR = 0.7;
+/** A stage's bar: its left, top, width and height, in px; `null` without a value. */
+export declare function stageBar(series: ChartSeries<FunnelStyle>, view: ChartView, i: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;
+export declare const funnelKind: ChartSeriesKind<FunnelStyle>;

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

@@ -0,0 +1,18 @@
+export interface PointGrid {
+    /** The data's x and y stretch the cells cover. */
+    x0: number;
+    y0: number;
+    /** Cells across and down, and the size of one in data numbers. */
+    columns: number;
+    rows: number;
+    width: number;
+    height: number;
+    /** Where each cell's points start in `items`; the cell after ends them. */
+    starts: Int32Array;
+    /** The points, cell by cell. */
+    items: Int32Array;
+}
+/** The grid of the points `(xs[i], ys[i])`; points with a `NaN` are left out. Cached per data. */
+export declare function pointGrid(xs: Float64Array, ys: Float64Array): PointGrid;
+/** Calls `visit` with each point in the cells that touch the data box from `(xa, ya)` to `(xb, yb)`. */
+export declare function eachNear(grid: PointGrid, xa: number, xb: number, ya: number, yb: number, visit: (index: number) => void): void;

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

@@ -0,0 +1,17 @@
+import type { ChartSeries, ChartSeriesKind } from './series';
+export interface HeatmapStyle {
+    /** The value the scale starts at; by default the smallest. */
+    min?: number;
+    /** The value the scale ends at; by default the largest. */
+    max?: number;
+}
+/** The values a heatmap's scale runs between: `min` and `max` as given, else the data's ends. */
+export declare function heatRange(series: Pick<ChartSeries<HeatmapStyle>, 'props' | 'y'>): [number, number] | null;
+/** Where `value` falls on the scale, 0 to 1. */
+export declare function heatShare(value: number, range: [number, number]): number;
+/**
+ * The color at `share` (0 to 1) of a scale from `surface` to `color`,
+ * mixed in OKLab so equal steps look equal; the smallest still shows.
+ */
+export declare function heatColor(color: string, surface: string, share: number): string;
+export declare const heatmapKind: ChartSeriesKind<HeatmapStyle>;

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

@@ -0,0 +1,23 @@
+import { type BarStyle } from './bar';
+import type { ChartSeriesKind } from './series';
+/** The most bins a histogram has: more would be thinner than a pixel, and slow. */
+export declare const MAX_BINS = 1000;
+export interface HistogramBin {
+    /** Where the bin starts, inclusive. */
+    x0: number;
+    /** Where it ends: exclusive, but for the last bin. */
+    x1: number;
+    /** Its middle, where the bar is placed. */
+    x: number;
+    count: number;
+}
+/**
+ * Counts `values` into bins of width `step`, or of a round width giving
+ * about `count` bins (by default, by the number of values: Sturges' rule).
+ * Values that aren't numbers are left out.
+ */
+export declare function histogramBins(values: ArrayLike<number>, { count, step }?: {
+    count?: number;
+    step?: number;
+}): HistogramBin[];
+export declare const histogramKind: ChartSeriesKind<BarStyle>;

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

@@ -0,0 +1,31 @@
+import type { Scale } from './scale';
+/** The indices of `values` from the smallest to the largest, `NaN` left out. Cached per array. */
+export declare function sortedOrder(values: Float64Array): Int32Array;
+/**
+ * Notes that `values` go up with no gaps, so their order is just
+ * 0, 1, 2…: shared, so it costs nothing to make.
+ */
+export declare function inOrder(values: Float64Array): void;
+/** How far `value` is from the nearest other value of `values`; `Infinity` when there is none. */
+export declare function neighborGap(values: Float64Array, value: number): number;
+/** The row of `values` whose value is exactly `value`, or -1. */
+export declare function rowAt(values: Float64Array, value: number): number;
+/**
+ * Of all the x values of `columns`, the one nearest to `pixel` along the
+ * x scale; `null` when there are none. Category axes snap to the nearest
+ * category.
+ */
+export declare function nearestX(columns: Float64Array[], scale: Scale, pixel: number): number | null;
+/** The x values of `columns` together, from the smallest, each once. */
+export declare function allX(columns: Float64Array[]): number[];
+/**
+ * The point nearest to `(px, py)` among `n` points placed by `point`,
+ * if one is within `reach(i)` px of it. Points of equal distance go to the
+ * one drawn last, which is on top.
+ */
+export declare function nearestPoint(n: number, point: (i: number) => [number, number] | null, px: number, py: number, reach: (i: number) => number): {
+    index: number;
+    distance: number;
+} | null;
+/** Angles clockwise from 12 o'clock, as pies use them. */
+export declare function angleAt(cx: number, cy: number, px: number, py: number): number;

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

@@ -0,0 +1,45 @@
+import type { Rect } from './painter';
+import type { ChartLabelAnchor } from './series';
+/** Height of a label's box, as tick labels. */
+export declare const DATA_LABEL = 16;
+export interface DataLabelInput {
+    key: string;
+    /** The series' index. */
+    series: number;
+    text: string;
+    anchor: ChartLabelAnchor;
+    /** Room from the point, past a dot or a line. */
+    offset?: number;
+}
+export interface PlacedDataLabel {
+    key: string;
+    series: number;
+    text: string;
+    /** The box's top left, in px from the chart's top left. */
+    left: number;
+    top: number;
+    /** Which end of the text `left` is. */
+    align: 'start' | 'middle' | 'end';
+    /** In a bar: the color of the bar, for text that reads on it. */
+    on?: string;
+}
+type Box = [left: number, top: number, right: number, bottom: number];
+/**
+ * Places labels in the order given; one that covers a label placed before
+ * it (or one of `taken`), or doesn't fit in `bounds` (or in its bar), is
+ * left out.
+ */
+export declare function placeDataLabels(inputs: DataLabelInput[], bounds: Rect, measure: (text: string) => number, 
+/** Labels already there that these must not cover (the ends of lines, say). */
+taken?: Box[]): PlacedDataLabel[];
+/**
+ * Moves boxes of `height` centered at `centers` apart along one line so
+ * none overlaps the next, keeping each as near its own center as it can
+ * and all within `[from, to]`. Gives the new centers, in the same order.
+ */
+export declare function spread(centers: number[], height: number, from: number, to: number): number[];
+/** Relative luminance of an `rgb()` / `rgba()` color (as the browser gives computed colors), 0 to 1. */
+export declare function luminance(color: string): number | null;
+/** Contrast ratio between two luminances. */
+export declare const contrast: (a: number, b: number) => number;
+export {};

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

@@ -0,0 +1,259 @@
+import type { ChartModel } from './model';
+import type { Rect } from './painter';
+import { type Scale } from './scale';
+import type { ChartValueAxis } from './series';
+import { type Window } from './window';
+/** Where an axis is drawn. */
+export type ChartAxisPosition = 'bottom' | 'top' | 'left' | 'right';
+/** What an axis measures: x, the values, or a second kind of values. */
+export type ChartAxisRole = 'x' | ChartValueAxis;
+export type ChartAxisType = 'linear' | 'log' | 'time' | 'category';
+/** A tick value as `format` receives it: a number, a `Date` on time axes, the category on category axes. */
+export type ChartTickValue = number | Date | string;
+/** An axis as configured, with defaults filled in. `position` is where it is drawn. */
+export interface AxisConfig {
+    position: ChartAxisPosition;
+    type?: ChartAxisType;
+    min?: number | string | Date;
+    max?: number | string | Date;
+    zero?: boolean;
+    nice?: boolean;
+    ticks?: number | Array<number | string | Date>;
+    format?: (value: any) => string;
+    grid: boolean;
+    title?: string;
+    hidden: boolean;
+    /** The room for tick labels down the side, in px, whatever they measure. */
+    labelWidth?: number;
+    /** Runs the other way: its scale's range is turned round. */
+    reverse?: boolean;
+}
+/** The axes by what they measure. */
+export interface ChartAxes {
+    x: AxisConfig;
+    y: AxisConfig | null;
+    y2: AxisConfig | null;
+}
+export interface TickLabel {
+    text: string;
+    /** Where the label's box goes, in px from the chart's top left. */
+    left: number;
+    top: number;
+    width: number;
+    /** Whether the text is longer than `width` and is cut short with an ellipsis. */
+    clipped?: boolean;
+}
+export interface AxisLayout {
+    /** Where the axis is drawn. */
+    position: ChartAxisPosition;
+    scale: Scale;
+    /** Tick values, as numbers on the scale. */
+    ticks: number[];
+    labels: TickLabel[];
+    grid: boolean;
+    title?: {
+        text: string;
+        left: number;
+        top: number;
+        align: 'start' | 'end';
+    };
+    /** The whole domain, when zoomed in to part of it (`scale.domain`). */
+    full: [number, number];
+}
+export interface ChartLayout {
+    width: number;
+    height: number;
+    plot: Rect;
+    x: AxisLayout;
+    /** The value axes, by what they measure. */
+    y: Partial<Record<ChartValueAxis, AxisLayout>>;
+    legend: LegendItem[];
+    /** The room the legend shows in; its entries scroll in it when they don't all fit. */
+    legendBox?: LegendBox;
+    /** Where the range strip goes: under the chart, or down its right side when horizontal. */
+    strip?: Rect;
+}
+/** Where a chart's legend goes. */
+export type ChartLegendPlacement = 'top' | 'bottom' | 'right';
+/** The room a legend shows in, in px from the chart's top left. */
+export interface LegendBox extends Rect {
+    /** Its entries take more room than it has: they scroll in it. */
+    scroll: boolean;
+}
+/** A legend entry, placed. */
+export interface LegendItem {
+    /** The entry's position in the names given. */
+    index: number;
+    text: string;
+    left: number;
+    top: number;
+    width: number;
+    /** The name is longer than the room down the side, and is cut short. */
+    clipped?: boolean;
+    /** The swatch's width, when wider than a series' (a heatmap's scale). */
+    swatch?: number;
+}
+/** A legend entry's name, or its name and a wider swatch (a heatmap's scale). */
+export type LegendName = string | {
+    text: string;
+    swatch: number;
+};
+/** Height of a line of tick text, and the room between it and the plot. */
+export declare const LABEL_HEIGHT = 16;
+export declare const LABEL_GAP = 8;
+/** Room left around the plot so lines and dots at the edge aren't cut. */
+export declare const EDGE = 8;
+/** Room between text and the chart's sides. */
+export declare const INSET = 4;
+/** A heatmap's scale in the legend: wide enough to read from light to dark. */
+export declare const HEAT_SWATCH = 40;
+/** The range strip's height (its width when horizontal), and the room before it. */
+export declare const STRIP = 32;
+interface LayoutOptions {
+    model: ChartModel;
+    axes: ChartAxes;
+    /** x runs down the left side and values along the bottom (and the top). */
+    horizontal?: boolean;
+    width: number;
+    height: number;
+    locale: string;
+    measure: (text: string) => number;
+    /** Names for a legend, or none. */
+    legend?: LegendName[];
+    /** Rows of the legend far enough apart for a finger to press each (on a touch screen). */
+    coarse?: boolean;
+    /** Where the legend goes: under the chart (the default), above it, or down its right side. */
+    legendPlacement?: ChartLegendPlacement;
+    /**
+     * The stretches shown when zoomed in: of x in the scale's numbers
+     * (category indices, ms), of the values in those of `y` (or `y2` when
+     * it is alone; `y2` follows `y`).
+     */
+    zoom?: {
+        x?: Window | null;
+        y?: Window | null;
+    };
+    /** Leave room for a range strip. */
+    strip?: boolean;
+    /** Room past the plot's end along x, in px, for labels at the ends of lines. */
+    trailing?: number;
+}
+/** Places the axes and works out the plot area, the scales and the tick labels. */
+export declare function layoutChart(options: LayoutOptions): ChartLayout;
+/**
+ * Places a legend's entries where it goes: in rows under or above the
+ * chart, or one under another down its right side. Gives the room it
+ * takes from the chart on each side, and the box it shows in: past three
+ * rows (or the chart's height, down the side), its entries scroll.
+ */
+export declare function placeLegendIn(names: LegendName[], at: ChartLegendPlacement, width: number, height: number, measure: (text: string) => number, coarse?: boolean): {
+    legend: LegendItem[];
+    box?: LegendBox;
+    room: {
+        top: number;
+        bottom: number;
+        right: number;
+    };
+};
+/** Entries in rows that fit `width`, each row centered; `top` counts from the first row. */
+export declare function placeLegend(names: LegendName[], width: number, measure: (text: string) => number, coarse?: boolean): LegendItem[];
+export interface PieLayout {
+    width: number;
+    height: number;
+    /** The center and the outer radius, in px. */
+    cx: number;
+    cy: number;
+    radius: number;
+    /** The lowest the pie's labels may go: above the legend. */
+    bottom: number;
+    legend: LegendItem[];
+    legendBox?: LegendBox;
+}
+/**
+ * The box round the part of a circle of radius 1 from `start` to `end`
+ * (radians clockwise from 12 o'clock), its center included, in units of
+ * the radius from the center: a half circle is half as tall as a whole.
+ */
+export declare function arcBox(start: number, end: number): {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+/** Room from a pie's edge to the labels outside it: the line out, and the gap before the text. */
+export declare const PIE_LABEL_ROOM = 24;
+/**
+ * A pie as large as fits above its legend; with labels outside, as large
+ * as leaves room for the widest of them on each side, moved over towards
+ * the side with the narrower labels.
+ */
+export declare function layoutPie({ width, height, measure, legend: names, coarse, legendPlacement, sideLabels, arc, }: Pick<LayoutOptions, 'width' | 'height' | 'measure' | 'legend' | 'coarse' | 'legendPlacement'> & {
+    /** The widest label outside the pie on each side, in px; 0 for none. */
+    sideLabels?: {
+        left: number;
+        right: number;
+    };
+    /** The part of the turn the pie takes (a half donut's), in radians from 12 o'clock. */
+    arc?: [number, number];
+}): PieLayout;
+/** A radar laid out: its center and radius, its rings and the names round it. */
+export interface RadarLayout {
+    width: number;
+    height: number;
+    cx: number;
+    cy: number;
+    radius: number;
+    /** How many spokes: one per category. */
+    count: number;
+    /** From a value to its distance from the center, in px. */
+    scale: Scale;
+    /** The values of the rings. */
+    ticks: number[];
+    /** The spokes' names round the rim. */
+    labels: TickLabel[];
+    /** The rings' values, between the first two spokes. */
+    values: TickLabel[];
+    legend: LegendItem[];
+    legendBox?: LegendBox;
+}
+/**
+ * Lays out a radar: the legend first, then the largest circle that leaves
+ * room round it for the spokes' names (the categories), with rings at
+ * nice values from the center (0, or the smallest value below it) out.
+ */
+export declare function layoutRadar({ model, axes, width, height, locale, measure, legend: names, coarse, legendPlacement, spokes, }: Omit<LayoutOptions, 'horizontal' | 'zoom' | 'strip' | 'trailing'> & {
+    /** The spokes' names, in order from 12 o'clock. */
+    spokes: string[];
+}): RadarLayout;
+/** A funnel laid out: where its stages go, and their names and values beside them. */
+export interface FunnelLayout {
+    width: number;
+    height: number;
+    /** Where the bars go: the widest takes its whole width. */
+    plot: Rect;
+    /** How many stages, and the height of each one's row. */
+    count: number;
+    step: number;
+    /** From a value to half its bar's width, in px. */
+    scale: Scale;
+    /** The stages' names, on the left. */
+    names: TickLabel[];
+    /** Their values, on the right, and the share each kept of the one before it. */
+    values: TickLabel[];
+    rates: TickLabel[];
+    legend: LegendItem[];
+    legendBox?: LegendBox;
+}
+/**
+ * Lays out a funnel: the legend, then the names in a column on the left
+ * and the values (with rates) on the right, and the bars between them.
+ */
+export declare function layoutFunnel({ width, height, measure, legend: names, coarse, legendPlacement, stages, values: written, rates: rateTexts, max, }: Pick<LayoutOptions, 'width' | 'height' | 'measure' | 'legend' | 'coarse' | 'legendPlacement'> & {
+    stages: string[];
+    values: string[];
+    /** The share each stage kept of the one before, written; `null` for the first. */
+    rates: Array<string | null>;
+    /** The largest value: its bar is the widest. */
+    max: number;
+}): FunnelLayout;
+export {};

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

@@ -0,0 +1,36 @@
+import { type Painter } from './painter';
+import type { ChartLabelAnchor, ChartSeries, ChartSeriesKind, ChartView } from './series';
+export interface LineStyle {
+    smooth?: boolean;
+    dots?: boolean | 'auto';
+    dashed?: boolean;
+    lineWidth?: number;
+    connectNulls?: boolean;
+    step?: boolean | 'before' | 'after' | 'middle';
+    labelPosition?: 'point' | 'end';
+    /** An area's bottom of its own (a band); the model reads it into `base`. */
+    y0?: unknown;
+}
+type StepMode = 'before' | 'after' | 'middle';
+/**
+ * The corners of a line that steps through `count` points: `after` holds
+ * each value until the next x, `before` takes the next value at once,
+ * `middle` changes halfway. Gives the corners' x, the values (`ys`, and
+ * `bs` for an area's bottom, stepped the same way) and how many there are.
+ */
+export declare function stepPoints(px: ArrayLike<number>, ys: ArrayLike<number>, bs: ArrayLike<number>, count: number, mode: StepMode): {
+    x: Float64Array;
+    y: Float64Array;
+    b: Float64Array;
+    count: number;
+};
+/** Draws a line, and with `area` the area under it (or under its slice of a stack). */
+export declare function drawLine(painter: Painter, series: ChartSeries<LineStyle>, view: ChartView, area: boolean): void;
+/**
+ * Where a line's labels go: above each point when there is room for them
+ * all, or beside the last point shown (`end`).
+ */
+export declare function lineLabels(series: ChartSeries<LineStyle>, view: ChartView): ChartLabelAnchor[];
+export declare const lineKind: ChartSeriesKind<LineStyle>;
+export declare const areaKind: ChartSeriesKind<LineStyle>;
+export {};

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

@@ -0,0 +1,67 @@
+import type { Tone } from 'dou-ui';
+import { type Painter, type Rect } from './painter';
+import type { Scale } from './scale';
+import type { ChartValueAxis } from './series';
+/** A marker as the chart reads it: x already as a number on the x scale. */
+export interface MarkerInput {
+    /** One x, or the two ends of a band of x; `null` when not given. */
+    x: [number, number] | number | null;
+    y: [number, number] | number | null;
+    /** The value axis `y` is on. */
+    axis: ChartValueAxis;
+    label?: string;
+    tone: Tone;
+    solid: boolean;
+}
+export type MarkerShape = 
+/** A line down the chart (`vertical`) or across it, at `at`, from `from` to `to`. */
+{
+    kind: 'line';
+    vertical: boolean;
+    at: number;
+    from: number;
+    to: number;
+} | ({
+    kind: 'area';
+} & Rect) | {
+    kind: 'point';
+    x: number;
+    y: number;
+};
+export interface MarkerLabel {
+    text: string;
+    left: number;
+    top: number;
+    /** Which end of the text `left` is: its start, its middle or its end. */
+    align: 'start' | 'middle' | 'end';
+}
+export interface PlacedMarker {
+    shape: MarkerShape;
+    tone: Tone;
+    solid: boolean;
+    label: MarkerLabel | null;
+}
+/** A point's dot. */
+export declare const MARKER_DOT = 4;
+interface PlaceOptions {
+    plot: Rect;
+    /** The x scale; with `horizontal`, it runs down the left side. */
+    x: Scale;
+    /** A value axis' scale; `null` when the chart has no such axis. */
+    y: (axis: ChartValueAxis) => Scale | null;
+    horizontal: boolean;
+    measure: (text: string) => number;
+}
+/** Where each marker is drawn, and its label; markers wholly off the plot are left out. */
+export declare function placeMarkers(markers: MarkerInput[], options: PlaceOptions): PlacedMarker[];
+export interface MarkerColors {
+    line: string;
+    /** A point's dot: the line's color, solid. */
+    dot: string;
+    /** A band. */
+    fill: string;
+    surface: string;
+}
+/** Draws the bands (`under` the series) or the lines and points (over them). */
+export declare function drawMarkers(painter: Painter, markers: PlacedMarker[], colors: (tone: Tone) => MarkerColors, dpr: number, under: boolean): void;
+export {};

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

@@ -0,0 +1,86 @@
+import { type ChartAccessor, type ChartData, type XColumn, type XKind } from './data';
+import type { ChartSeriesKind, ChartSeriesProps, ChartValueAxis } from './series';
+/** A series as registered by its component. */
+export interface SeriesInput {
+    index: number;
+    kind: ChartSeriesKind<any>;
+    props: ChartSeriesProps & {
+        stack?: string | boolean;
+        /** An area's bottom of its own: a band from it up to `y`. */
+        y0?: ChartAccessor;
+        /** A heatmap's value of each cell (its `y` names the row's category). */
+        value?: ChartAccessor;
+    } & Record<string, unknown>;
+    /** Turned off (in the legend): left out of the axes and not drawn. */
+    hidden?: boolean;
+}
+/** What a series is called: its `name`, else its `y` key, else its place. */
+export declare function seriesName(input: Pick<SeriesInput, 'index' | 'props'>): string;
+/** A series with its data read, before colors are worked out. */
+export interface ModelSeries {
+    input: SeriesInput;
+    name: string;
+    rows: ChartData;
+    axis: ChartValueAxis;
+    x: XColumn;
+    y: Float64Array;
+    top: Float64Array;
+    base: Float64Array | null;
+    stackEnds: {
+        up: Float64Array;
+        down: Float64Array;
+    } | null;
+    slot: {
+        index: number;
+        count: number;
+    } | null;
+    /** A heatmap's categories down the value axis, as read. */
+    yColumn?: XColumn;
+}
+export interface ChartModel {
+    series: ModelSeries[];
+    xKind: XKind;
+    categories: string[];
+    /** The smallest and largest x (for `category`: the first and last category index). */
+    x: [number, number] | null;
+    /** The smallest and largest value on each y axis, with 0 when a series grows from it. */
+    y: Record<ChartValueAxis, [number, number] | null>;
+    /** Whether each y axis must reach 0. */
+    zero: Record<ChartValueAxis, boolean>;
+    /** The categories of value axes that list them (a heatmap's rows), first at the top; `null` for number axes. */
+    yCategories: Record<ChartValueAxis, string[] | null>;
+    /** Whether every x is a whole number (years, counts): the x axis then has no ticks in between. */
+    xIntegers: boolean;
+    /**
+     * For series that take a band of each x (bars) on a number or time axis:
+     * the smallest distance between two x values, which is one band. `NaN`
+     * when there is no such series or no two values.
+     */
+    xStep: number;
+    /** The most room any series needs around its points, in px (bubbles). */
+    inset: number;
+}
+/**
+ * Reads the data of every shown series into columns, lines up categories
+ * shared by series with their own data, stacks what stacks, and finds the
+ * range of each axis.
+ */
+export declare function buildModel(inputs: SeriesInput[], chart: {
+    data: ChartData;
+    x?: ChartAccessor;
+    xKind?: XKind;
+    /** The y axis of series that don't name one. */
+    axis?: ChartValueAxis;
+    /** Value axes whose stacks show each part's share of the whole (0 to 1). */
+    percent?: Partial<Record<ChartValueAxis, boolean>>;
+    /**
+     * The order of the categories along x: by their totals (the sum of the
+     * shown series' values), or as a function of two category names orders
+     * them. As they come in the data when not given.
+     */
+    sort?: ChartCategorySort;
+}): ChartModel;
+/** How categories along x are ordered: by their totals, or by a comparison of their names. */
+export type ChartCategorySort = 'asc' | 'desc' | ((a: string, b: string) => number);
+/** The smallest distance between two different values, or `NaN` with fewer than two. */
+export declare function smallestGap(values: Float64Array): number;

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

@@ -0,0 +1,34 @@
+/**
+ * What drawing code may use of a 2D context. Series draw only through
+ * this, so the same code can later draw into something other than a
+ * canvas (an SVG for export) and look the same.
+ */
+export type Painter = Pick<CanvasRenderingContext2D, 'save' | 'restore' | 'beginPath' | 'closePath' | 'moveTo' | 'lineTo' | 'bezierCurveTo' | 'rect' | 'arc' | 'arcTo' | 'fill' | 'stroke' | 'clip' | 'setLineDash' | 'drawImage' | 'fillStyle' | 'strokeStyle' | 'lineWidth' | 'lineJoin' | 'lineCap' | 'globalAlpha'>;
+/** A rectangle in CSS px. */
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Moves a coordinate onto the pixel grid so a line `width` CSS px wide
+ * covers whole device pixels and stays sharp.
+ */
+export declare function crisp(value: number, dpr: number, width?: number): number;
+/**
+ * Traces a line through the points `px[i], py[i]` into the current path.
+ * With `smooth`, a monotone curve: it bends through every point without
+ * swinging above or below a neighbor, so a peak in the curve is a peak in
+ * the data. `reverse` traces from the last point back to the first (the
+ * lower edge of an area); the curve is the same either way. With `swap`,
+ * `px` are tops and `py` lefts: the line runs down (a horizontal chart).
+ */
+export declare function tracePoints(painter: Painter, px: ArrayLike<number>, py: ArrayLike<number>, count: number, { smooth, reverse, join, swap }?: {
+    smooth?: boolean | undefined;
+    reverse?: boolean | undefined;
+    join?: boolean | undefined;
+    swap?: boolean | undefined;
+}): void;
+/** Slopes at each point that keep a cubic curve monotone between points (Fritsch–Carlson). */
+export declare function monotoneTangents(px: ArrayLike<number>, py: ArrayLike<number>, count: number): Float64Array;