inkplot 0.0.0-stage → 1.0.0-beta.1

package/dist/cursor.js

@@ -0,0 +1,344 @@
+/**
+ * The cursor: where the user is pointing in a plane, and what is there. It draws nothing itself. It works out, from the
+ * mouse or from the keyboard, a `CursorState`, and the elements inside it (a `Crosshair`, a `ChartTooltip`, anything of
+ * your own) draw from that:
+ *
+ *   new Chart({}, plane, new Cursor({ mode: 'shared' }, new Crosshair({ lines: 'first' }), new ChartTooltip()))
+ *
+ * Keeping the finding apart from the drawing is what lets them be mixed freely: a crosshair with no tooltip, a tooltip with
+ * no crosshair, two tooltips, one at the point and one in the corner, all reading the same cursor.
+ *
+ * Two ways to move it
+ * ───────────────────
+ * With the pointer, it is wherever the pointer is over a plane. With the keyboard, the plot is a tab stop: Left and Right step
+ * from point to point of a series (skipping gaps), Up and Down move to the previous or next series, Home and End go to
+ * the first and last point, PageUp and PageDown jump a tenth of the series, and Escape puts the cursor away. The keys are
+ * configurable (`keys`, as for `PanZoom`), and `keys: false` leaves the cursor to the pointer alone and takes it out of the
+ * tab order. Whichever moved last has the cursor. Name the plot with `meta.title`: it is what a screen reader says on arriving.
+ *
+ * What it finds
+ * ─────────────
+ *  - 'nearest' (the default): the one point nearest the pointer, as the series' `hit` settings measure it (hit.ts); with the
+ *    keyboard, the point stepped to.
+ *  - 'shared': every series at the cursor's place along the first axis, so a line chart is read across all its lines at once.
+ *    It is measured along the axis and not in pixels, so on a polar plane it is every series at the pointer's angle.
+ * `interpolate` reads the line between its points where the pointer is, in place of the nearest point.
+ *
+ * It holds no words: what a tooltip says is the tooltip's, and a screen reader hears the tooltip's text for a cursor moved
+ * by keyboard (see `Platform.announce`).
+ */
+/* oxlint-disable typescript/no-non-null-assertion -- numeric kernels over flat typed-array buffers (stride-addressed rows): every index is bounded by the row count, which `noUncheckedIndexedAccess` cannot see */
+import { AUTO, STRING } from './attrs.js';
+import { writeAria } from './aria.js';
+import { ChartElement, resolveRef } from './element.js';
+import { inputOf } from './input.js';
+import { EVENT_ATTACH, EVENT_FOCUS, EVENT_HOVER, EVENT_KEY, EVENT_PAINT } from './events.js';
+import { drawFocusRing, makeTabStop } from './focus.js';
+import { hitAcross, hitPlane, interpolate, interpolateAll, pointHit } from './hit.js';
+import { Plane } from './plane.js';
+export const DEFAULT_CURSOR_KEYS = {
+    next: ['ArrowRight'], previous: ['ArrowLeft'], nextSeries: ['ArrowDown'], previousSeries: ['ArrowUp'],
+    first: ['Home'], last: ['End'], jumpNext: ['PageDown'], jumpPrevious: ['PageUp'], clear: ['Escape'],
+};
+const JUMP = 0.1;
+export class Cursor extends ChartElement {
+    static takesInput = inputOf;
+    static attrTypes = { ...ChartElement.attrTypes, plane: STRING, keys: { nextSeries: AUTO, previousSeries: AUTO, jumpNext: AUTO, jumpPrevious: AUTO } };
+    #pointer = null;
+    #by = 'pointer';
+    #focused = false;
+    #ring = false;
+    #node = null;
+    /** The point the keyboard is on. */
+    #at = null;
+    #version = 0;
+    #cache = null;
+    #signature = '';
+    #lastKeys = '';
+    /** The keys in force: the defaults with the ones asked for laid over them, or none. */
+    get keyMap() {
+        const k = this.attrs.keys;
+        return k === false ? null : { ...DEFAULT_CURSOR_KEYS, ...k };
+    }
+    /**
+     * Where the cursor is and what is there, or null when it is nowhere: the pointer is off the plot (or on its corner, for a
+     * round plot), a button is held (a drag), or the keyboard has put it away. Worked out afresh after each flush, since
+     * the data may have been edited, or the view panned, under a pointer that has not moved.
+     */
+    get state() {
+        const flush = this.chart?.flushCount ?? 0, cache = this.#cache;
+        if (cache && cache.version === this.#version && cache.flush === flush)
+            return cache.state;
+        const state = this.#compute();
+        this.#cache = { version: this.#version, flush, state };
+        return state;
+    }
+    /** The plane the cursor is tied to by `plane`, else the first. */
+    get plane() {
+        const ref = this.attrs.plane;
+        if (ref)
+            return resolveRef(ref, this, Plane);
+        for (const c of this.requireParent())
+            if (c instanceof Plane)
+                return c;
+        return null;
+    }
+    /** Put the keyboard cursor on a point of a series, as if stepped to, and show it. */
+    select(series, index) {
+        this.#at = { series, index };
+        this.#by = 'keyboard';
+        this.#changed(true);
+    }
+    onEvent(ev) {
+        switch (ev.type) {
+            case EVENT_ATTACH:
+                inputOf(this.requireParent()).watchPointer(this);
+                break;
+            case EVENT_HOVER: {
+                const pinned = this.attrs.plane ? this.plane : null;
+                if (pinned && ev.plane !== pinned)
+                    break;
+                this.#pointer = ev.x === ev.x ? { plane: ev.plane, x: ev.x, y: ev.y, buttons: ev.buttons } : null;
+                // The pointer leaving ends only what the pointer was doing: a cursor the keyboard put there stays.
+                if (this.#pointer)
+                    this.#by = 'pointer';
+                this.#changed(false);
+                break;
+            }
+            case EVENT_KEY:
+                this.#key(ev);
+                break;
+            case EVENT_FOCUS:
+                if (ev.node !== this.#node)
+                    break;
+                this.#focused = ev.focused;
+                this.#ring = ev.focused && ev.visible;
+                if (ev.focused) {
+                    this.#by = 'keyboard';
+                    this.#begin();
+                }
+                else if (this.#by === 'keyboard')
+                    this.#by = 'pointer';
+                this.#changed(true);
+                break;
+            case EVENT_PAINT:
+                this.#paintFocus();
+                break;
+        }
+    }
+    /** The keyboard's point: nothing yet means the first point of the first series. */
+    #begin() {
+        if (this.#at && this.#valid(this.#at))
+            return;
+        const plane = this.plane;
+        this.#at = null;
+        if (!plane)
+            return;
+        for (const series of this.#steppable(plane)) {
+            const index = this.#step(series, -1, 1);
+            if (index >= 0) {
+                this.#at = { series, index };
+                return;
+            }
+        }
+    }
+    /** Series the keyboard can stop on: shown, drawn, and taking hits. */
+    #steppable(plane) {
+        return plane.series.filter((s) => s.attrs.hit !== false && (s.drawn?.points.count ?? 0) > 0);
+    }
+    #valid(at) {
+        const plane = this.plane, d = at.series.drawn;
+        return !!plane && at.series.shown && at.series.plane === plane && !!d && at.index < d.points.count && this.#real(at.series, at.index);
+    }
+    /** Whether drawn point `index` is a point and not a gap. */
+    #real(series, index) {
+        const p = series.drawn?.points;
+        if (!p)
+            return false;
+        return p.data[index * p.stride] === p.data[index * p.stride] && p.data[index * p.stride + 1] === p.data[index * p.stride + 1];
+    }
+    /** The point `by` steps from `from` that is not a gap, or -1 when there is none that way. */
+    #step(series, from, by) {
+        const n = series.drawn?.points.count ?? 0;
+        for (let k = from + by; k >= 0 && k < n; k += by)
+            if (this.#real(series, k))
+                return k;
+        return -1;
+    }
+    #key(ev) {
+        const map = this.keyMap;
+        if (!map || ev.kind !== 'down' || ev.node !== this.#node || ev.ctrl || ev.alt || ev.shift)
+            return;
+        let action;
+        // oxlint-disable-next-line typescript/consistent-type-assertions -- `for…in` gives `string`; the keys of `map` are `CursorAction`s
+        for (const name in map)
+            if (map[name].includes(ev.key)) {
+                action = name;
+                break;
+            }
+        if (!action)
+            return;
+        const plane = this.plane;
+        if (!plane)
+            return;
+        if (action === 'clear') {
+            if (this.state) {
+                ev.handled = true;
+                this.#at = null;
+                this.#by = 'keyboard';
+                this.#changed(true);
+            }
+            return;
+        }
+        ev.handled = true;
+        this.#by = 'keyboard';
+        if (!this.#at || !this.#valid(this.#at))
+            this.#begin();
+        const at = this.#at;
+        if (!at) {
+            this.#changed(true);
+            return;
+        }
+        const n = at.series.drawn?.points.count ?? 0;
+        const jump = Math.max(1, Math.round(n * JUMP));
+        let index = -1;
+        switch (action) {
+            case 'next':
+                index = this.#step(at.series, at.index, 1);
+                break;
+            case 'previous':
+                index = this.#step(at.series, at.index, -1);
+                break;
+            case 'jumpNext':
+                index = this.#reach(at, jump, 1);
+                break;
+            case 'jumpPrevious':
+                index = this.#reach(at, jump, -1);
+                break;
+            case 'first':
+                index = this.#step(at.series, -1, 1);
+                break;
+            case 'last':
+                index = this.#step(at.series, n, -1);
+                break;
+            case 'nextSeries':
+            case 'previousSeries': {
+                const list = this.#steppable(plane), at0 = list.indexOf(at.series), other = list[at0 + (action === 'nextSeries' ? 1 : -1)];
+                if (other)
+                    this.#at = { series: other, index: this.#alongTo(at, other) };
+                this.#changed(true);
+                return;
+            }
+        }
+        if (index >= 0)
+            this.#at = { series: at.series, index };
+        this.#changed(true);
+    }
+    /** `count` real points on from a point, or the last one reached before running out. */
+    #reach(at, count, by) {
+        let index = at.index;
+        for (let k = 0; k < count; k++) {
+            const next = this.#step(at.series, index, by);
+            if (next < 0)
+                break;
+            index = next;
+        }
+        return index === at.index ? -1 : index;
+    }
+    /** The point of `to` nearest the point `from` is on, along the first axis, so moving to another series keeps one's place in the domain. */
+    #alongTo(from, to) {
+        const a = from.series.drawn, b = to.drawn;
+        if (!a || !b)
+            return this.#step(to, -1, 1);
+        const at = from.index * a.stride + a.firstColumn;
+        const axis = to.firstAxis, target = axis.fractionOf(a.raw[at]);
+        let best = this.#step(to, -1, 1), bestD = Infinity;
+        for (let k = 0; k < b.points.count; k++) {
+            if (!this.#real(to, k))
+                continue;
+            const d = Math.abs(axis.fractionOf(b.raw[k * b.stride + b.firstColumn]) - target);
+            if (d < bestD) {
+                bestD = d;
+                best = k;
+            }
+        }
+        return best;
+    }
+    /** The state for the input as it stands. */
+    #compute() {
+        const a = this.attrs, shared = a.mode === 'shared';
+        if (this.#by === 'keyboard') {
+            const at = this.#at;
+            if (!at || !this.#focused || !this.#valid(at))
+                return null;
+            const hit = pointHit(at.series, at.index);
+            if (!hit)
+                return null;
+            const plane = at.series.plane;
+            const hits = shared ? this.#shared(plane, hit.px, hit.py, hit) : [hit];
+            return { plane, x: hit.px, y: hit.py, source: 'keyboard', hits };
+        }
+        const p = this.#pointer;
+        if (!p || p.plane.chart !== this.chart || (p.buttons & 1) || !p.plane.covers(p.x, p.y))
+            return null;
+        const { plane, x, y } = p;
+        if (shared)
+            return { plane, x, y, source: 'pointer', hits: this.#shared(plane, x, y, null) };
+        const hit = hitPlane(plane, x, y);
+        // Reading the line under the pointer; the nearest point was only what said it was near.
+        const read = hit && a.interpolate === true ? interpolate(hit.series, plane.unplace(x, y, hit.series.firstAxis, hit.series.secondAxis)[0]) ?? hit : hit;
+        return { plane, x, y, source: 'pointer', hits: read ? [read] : [] };
+    }
+    /** Every series at a place: the line read there, or the point nearest in the first axis. The keyboard's own point leads for a series it is on. */
+    #shared(plane, x, y, own) {
+        const hits = this.attrs.interpolate === true ? interpolateAll(plane, x, y) : hitAcross(plane, x, y);
+        if (own) {
+            const i = hits.findIndex((h) => h.series === own.series);
+            if (i >= 0)
+                hits[i] = own;
+        }
+        return hits;
+    }
+    /** Redraw when something that shows changed. `force`: the keyboard moved, which always does. */
+    #changed(force) {
+        this.#version++;
+        const state = this.state;
+        // oxlint-disable-next-line typescript/consistent-type-assertions -- a type guard in effect: probing a child for the optional `follows`
+        const moves = [...this].some((c) => c.attrs.visible !== false && c.follows === true);
+        const sig = !state ? '' : [
+            state.source, state.hits.map((h) => `${h.series.attrs.name ?? ''}:${h.row ?? h.index}:${h.first}:${h.second}`).join('|'),
+            moves || state.hits.length === 0 ? `@${state.x},${state.y}` : '',
+        ].join('#');
+        if (force || sig !== this.#signature) {
+            this.#signature = sig;
+            this.invalidate();
+        }
+    }
+    /** The plot as a tab stop, in the chart's pixels, with the ring when keyboard focus is on it. */
+    #paintFocus() {
+        const s = this.surface, plane = this.plane, map = this.keyMap;
+        if (!map || !plane) {
+            s.remove('focus');
+            s.remove('ring');
+            this.#node = null;
+            return;
+        }
+        const r = plane.rect, node = s.node('focus', 'rect');
+        s.set(node, 'x', r.x);
+        s.set(node, 'y', r.y);
+        s.set(node, 'width', r.width);
+        s.set(node, 'height', r.height);
+        s.set(node, 'fill', 'none');
+        s.set(node, 'pointer-events', 'none');
+        makeTabStop(s, node);
+        writeAria(s, node, this.attrs.meta ?? (plane.attrs.meta?.title !== undefined ? { title: plane.attrs.meta.title } : undefined), { role: 'application' });
+        const shortcuts = [...new Set(Object.values(map).flat())].join(' ');
+        if (shortcuts !== this.#lastKeys) {
+            this.#lastKeys = shortcuts;
+            s.set(node, 'aria-keyshortcuts', shortcuts);
+        }
+        inputOf(this.requireParent()).focusable(this, node);
+        this.#node = node;
+        drawFocusRing(s, 'ring', this.styleFor(['focusRing', 'line']), this.#ring ? { x: r.x + 3, y: r.y + 3, width: Math.max(0, r.width - 6), height: Math.max(0, r.height - 6) } : null);
+    }
+}

package/dist/curve.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Curves: how a line, or the edge of an area, joins the points of a series.
+ *
+ * A `Curve` is the one child of a `LinePath` or an `AreaPath`, and all it does is turn a series that has been projected
+ * (its points in plot pixels, and through them the plane and the data) into path text: `line` for the stroke, `area` for
+ * the shapes between the line and a baseline. So the renderers know nothing of how points are joined, and a new way of
+ * joining them is one new class that nothing else has to know about, nor any bundle that does not use it carry.
+ *
+ * `LinearCurve` here is the plain one, straight lines, and the only one every chart needs. The others are in `curves.ts`
+ * (splines, arcs, bumps) and `steps.ts` (levels and jumps worked out in the plane's own terms). To write one of your own,
+ * extend `Curve` and give `line` and `area`, or extend `StrokeCurve` (curves.ts) and say only what pieces a run of points
+ * is made of.
+ *
+ * A curve that draws something other than straight lines through the points also gives its path as a `Trace`, which is
+ * what hits and tooltip readings are measured against, so that they land on what is on the screen.
+ */
+import type { PointBuffer } from './data.ts';
+import { type BaseAttributes, ChartElement } from './element.ts';
+import type { AnySeriesRenderer, Trace } from './renderer.ts';
+import type { Series } from './series.ts';
+export interface CurveAttributes extends BaseAttributes {
+}
+/** Joins the points of a series. The child of a line or an area renderer. */
+export declare abstract class Curve<A extends CurveAttributes = CurveAttributes> extends ChartElement<AnySeriesRenderer, [], A> {
+    /** The path of the series' line: each run of it (a stretch between gaps, or the whole of it when the series' `gaps` are 'connect') starts with an M. */
+    abstract line(series: Series): string;
+    /** The path of the shapes between the series' line and its baseline, `baseline` being a value (in a stack, the layer below is used instead). */
+    abstract area(series: Series, baseline: number): string;
+    /**
+     * What `line` (with a null `baseline`) or `area` draws, as the vertices a pointer is measured against and the point each
+     * belongs to, or null when it is straight lines through the points, which hits measure by themselves. Default null.
+     */
+    trace(_series: Series, _baseline: number | null): Trace | null;
+}
+/**
+ * The path text through placed points, lifting the pen at each gap (or, with `connect`, going across it). Built as
+ * compactly as SVG allows (an implicit lineto after the first pair) because for large series its size is the cost.
+ */
+export declare function polyline(points: Readonly<PointBuffer>, connect: boolean): string;
+/**
+ * The closed shapes between a line and its baseline: the line forward and the baseline backward, one shape for each run
+ * of rows where both are real (or, with `connect`, a single shape of all the real ones). Both buffers are placed points
+ * in the same order, so row `i` of one is the foot of row `i` of the other.
+ */
+export declare function areaOutline(top: Readonly<PointBuffer>, base: Readonly<PointBuffer>, connect: boolean): string;
+/** Straight lines from point to point: what a line chart is. A gap lifts the pen, or is crossed if the series says its `gaps` are 'connect'. */
+export declare class LinearCurve extends Curve {
+    line(series: Series): string;
+    area(series: Series, baseline: number): string;
+}

package/dist/curve.js

@@ -0,0 +1,87 @@
+import { ChartElement } from './element.js';
+import { f2 } from './geometry.js';
+/** Joins the points of a series. The child of a line or an area renderer. */
+export class Curve extends ChartElement {
+    /**
+     * What `line` (with a null `baseline`) or `area` draws, as the vertices a pointer is measured against and the point each
+     * belongs to, or null when it is straight lines through the points, which hits measure by themselves. Default null.
+     */
+    trace(_series, _baseline) { return null; }
+}
+/**
+ * The path text through placed points, lifting the pen at each gap (or, with `connect`, going across it). Built as
+ * compactly as SVG allows (an implicit lineto after the first pair) because for large series its size is the cost.
+ */
+export function polyline(points, connect) {
+    const { data, count, stride } = points;
+    // Pen state: 0 up, 1 just moved, 2 drawing (implicit lineto pairs). A gap puts the pen up.
+    let d = '', pen = 0;
+    for (let i = 0; i < count; i++) {
+        const x = data[stride * i], y = data[stride * i + 1];
+        if (!Number.isFinite(x) || !Number.isFinite(y)) {
+            if (!connect)
+                pen = 0;
+            continue;
+        }
+        const xy = f2(x) + ' ' + f2(y);
+        switch (pen) {
+            case 0:
+                d += 'M' + xy;
+                pen = 1;
+                break;
+            case 1:
+                d += 'L' + xy;
+                pen = 2;
+                break;
+            default: d += ' ' + xy;
+        }
+    }
+    return d;
+}
+/**
+ * The closed shapes between a line and its baseline: the line forward and the baseline backward, one shape for each run
+ * of rows where both are real (or, with `connect`, a single shape of all the real ones). Both buffers are placed points
+ * in the same order, so row `i` of one is the foot of row `i` of the other.
+ */
+export function areaOutline(top, base, connect) {
+    const { data, count, stride } = top, b = base.data, bs = base.stride;
+    const ok = (i) => {
+        const x = data[i * stride], y = data[i * stride + 1], bx = b[bs * i], by = b[bs * i + 1];
+        return Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(bx) && Number.isFinite(by);
+    };
+    let d = '';
+    for (let i = 0; i < count;) {
+        if (!ok(i)) {
+            i++;
+            continue;
+        }
+        let end = i;
+        if (connect) {
+            for (let k = i + 1; k < count; k++)
+                if (ok(k))
+                    end = k;
+        }
+        else
+            while (end + 1 < count && ok(end + 1))
+                end++;
+        d += `M${f2(data[i * stride])} ${f2(data[i * stride + 1])}L`;
+        let first = true;
+        for (let k = i + 1; k <= end; k++) {
+            if (connect && !ok(k))
+                continue;
+            d += (first ? '' : ' ') + f2(data[k * stride]) + ' ' + f2(data[k * stride + 1]);
+            first = false;
+        }
+        for (let k = end; k >= i; k--)
+            if (!connect || ok(k))
+                d += ' ' + f2(b[bs * k]) + ' ' + f2(b[bs * k + 1]);
+        d += 'Z';
+        i = end + 1;
+    }
+    return d;
+}
+/** Straight lines from point to point: what a line chart is. A gap lifts the pen, or is crossed if the series says its `gaps` are 'connect'. */
+export class LinearCurve extends Curve {
+    line(series) { return polyline(series.points, series.attrs.gaps === 'connect'); }
+    area(series, baseline) { return areaOutline(series.points, series.baseline(baseline), series.attrs.gaps === 'connect'); }
+}

package/dist/curves.d.ts

@@ -0,0 +1,104 @@
+import { Curve, type CurveAttributes } from './curve.ts';
+import type { Trace } from './renderer.ts';
+import type { Series } from './series.ts';
+/** Receives the vertices of a sampled piece: where, and how far along the piece (0 to 1), which says which end owns it. */
+export type Push = (x: number, y: number, t: number) => void;
+/**
+ * One segment of a curve: where it ends (`x`, `y`), the (run-local) indices of the two points it runs between (`a`, `b`), so
+ * that a vertex on it can be given an owner, its path text beginning with the command letter, and a way to cut it into
+ * vertices for tracing from where the pen was.
+ */
+export interface Piece {
+    readonly cmd: string;
+    readonly d: string;
+    readonly x: number;
+    readonly y: number;
+    readonly a: number;
+    readonly b: number;
+    sample(x0: number, y0: number, push: Push): void;
+}
+/** A straight line to (x, y). */
+export declare function lineTo(x: number, y: number, a: number, b: number): Piece;
+/** A cubic Bézier with control points (x1, y1) and (x2, y2), ending at (x, y). */
+export declare function cubicTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number, a: number, b: number): Piece;
+/**
+ * One Hermite segment of a run as a cubic: from point `k` to `k + 1` of `p`, with the given tangents (derivatives with
+ * respect to a parameter that spans `h` over the segment) at its two ends.
+ */
+export declare function hermiteTo(p: ArrayLike<number>, k: number, lx: number, ly: number, rx: number, ry: number, h: number): Piece;
+/** A quadratic Bézier with control point (x1, y1), ending at (x, y). */
+export declare function quadTo(x1: number, y1: number, x: number, y: number, a: number, b: number): Piece;
+/** A smooth quadratic ending at (x, y), whose control point SVG reflects from the last piece; (cx, cy) is that reflected point, which tracing needs. */
+export declare function smoothTo(cx: number, cy: number, x: number, y: number, a: number, b: number): Piece;
+/** A circular arc of radius `r` to (x, y), on the side and of the size the flags pick (as the SVG `A` command with equal radii). */
+export declare function arcTo(r: number, large: 0 | 1, sweep: 0 | 1, x: number, y: number, a: number, b: number): Piece;
+/**
+ * A curve made of pieces. It says what the pieces through a run of points are (`pieces`), and this does the rest: the path
+ * text of a line and of an area, and the trace. Every run has at least two points; a single point draws nothing.
+ */
+export declare abstract class StrokeCurve<A extends CurveAttributes = CurveAttributes> extends Curve<A> {
+    #private;
+    /** The pieces of the curve through `p` (x, y pairs, two or more points) after its first point. `series` is given when drawing, for a curve that depends on its axes. */
+    protected abstract pieces(p: ArrayLike<number>, series?: Series): Piece[];
+    /**
+     * The path text through `p`, starting with `lead`: 'M' to begin a path at the first point, or 'L' to carry on from
+     * wherever the pen is (for the way back round an area).
+     */
+    path(p: ArrayLike<number>, lead: 'M' | 'L', series?: Series): string;
+    /** The curve through `p` as vertices, and for each the index (into `p`'s points) of the point it belongs to (the nearer end of the piece it is on). The same curve `path` writes. */
+    polyline(p: ArrayLike<number>, series?: Series): {
+        pts: number[];
+        owner: number[];
+    };
+    line(series: Series): string;
+    area(series: Series, baseline: number): string;
+    trace(series: Series, baseline: number | null): Trace | null;
+}
+/** A smooth line that never overshoots the data: a monotone cubic (Fritsch–Carlson). */
+export declare class MonotoneCurve extends StrokeCurve {
+    protected pieces(p: ArrayLike<number>): Piece[];
+}
+/** The natural cubic spline: the smoothest line through the points, which swings past them. */
+export declare class NaturalCurve extends StrokeCurve {
+    protected pieces(p: ArrayLike<number>): Piece[];
+}
+export interface CardinalCurveAttributes extends CurveAttributes {
+    /** How far the curve is tightened towards straight lines, 0 (the Catmull-Rom spline) to 1. Default 0. */
+    tension?: number;
+}
+/** A cardinal spline: through every point, with a tangent along the neighbours that `tension` shortens. */
+export declare class CardinalCurve extends StrokeCurve<CardinalCurveAttributes> {
+    protected pieces(p: ArrayLike<number>): Piece[];
+}
+export interface CatmullRomCurveAttributes extends CurveAttributes {
+    /** The spacing of the knots: 0 even, 0.5 centripetal, 1 chordal. Default 0.5. */
+    alpha?: number;
+}
+/** The Catmull–Rom spline: through every point, centripetal by default so that it neither loops nor cusps when the spacing is uneven. */
+export declare class CatmullRomCurve extends StrokeCurve<CatmullRomCurveAttributes> {
+    protected pieces(p: ArrayLike<number>): Piece[];
+}
+/** A uniform cubic B-spline, pulled towards the points rather than through them, starting at the first and ending at the last. */
+export declare class BasisCurve extends StrokeCurve {
+    protected pieces(p: ArrayLike<number>): Piece[];
+}
+export interface BumpCurveAttributes extends CurveAttributes {
+    /** Whether the level ends are along x (a line level at each point) or y. Default: along the series' first axis. */
+    along?: 'x' | 'y';
+}
+/** A level start and end to each segment and an S between: the flow of a bump chart or a sankey. */
+export declare class BumpCurve extends StrokeCurve<BumpCurveAttributes> {
+    protected pieces(p: ArrayLike<number>, series?: Series): Piece[];
+}
+/** Quadratic Béziers with each point as a control point, through the middles of the segments. */
+export declare class QuadraticCurve extends StrokeCurve {
+    protected pieces(p: ArrayLike<number>): Piece[];
+}
+export interface ArcCurveAttributes extends CurveAttributes {
+    /** The rise of each arc as a fraction of its chord, positive bulging to the left of the way along. Default 0.3. */
+    bend?: number;
+}
+/** A circular arc between each pair of points. */
+export declare class ArcCurve extends StrokeCurve<ArcCurveAttributes> {
+    protected pieces(p: ArrayLike<number>): Piece[];
+}