inkplot 0.0.0-stage → 1.0.0-beta.1

package/dist/curves.js

@@ -0,0 +1,375 @@
+import { Curve } from './curve.js';
+import { f2 } from './geometry.js';
+const pt = (x, y) => f2(x) + ' ' + f2(y);
+/** Vertices a Bézier or an arc is cut into, for tracing: enough that a chord is within a fraction of a pixel on a plot. */
+const SAMPLES = 16;
+/** A straight line to (x, y). */
+export function lineTo(x, y, a, b) {
+    return { cmd: 'L', d: 'L' + pt(x, y), x, y, a, b, sample: (_x0, _y0, push) => push(x, y, 1) };
+}
+/** A cubic Bézier with control points (x1, y1) and (x2, y2), ending at (x, y). */
+export function cubicTo(x1, y1, x2, y2, x, y, a, b) {
+    return {
+        cmd: 'C', d: 'C' + pt(x1, y1) + ' ' + pt(x2, y2) + ' ' + pt(x, y), x, y, a, b,
+        sample(x0, y0, push) {
+            for (let j = 1; j <= SAMPLES; j++) {
+                const t = j / SAMPLES, u = 1 - t;
+                push(u * u * u * x0 + 3 * u * u * t * x1 + 3 * u * t * t * x2 + t * t * t * x, u * u * u * y0 + 3 * u * u * t * y1 + 3 * u * t * t * y2 + t * t * t * y, t);
+            }
+        },
+    };
+}
+/**
+ * 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 function hermiteTo(p, k, lx, ly, rx, ry, h) {
+    return cubicTo(p[2 * k] + (lx * h) / 3, p[2 * k + 1] + (ly * h) / 3, p[2 * k + 2] - (rx * h) / 3, p[2 * k + 3] - (ry * h) / 3, p[2 * k + 2], p[2 * k + 3], k, k + 1);
+}
+function quadSample(qx, qy, x, y) {
+    return (x0, y0, push) => {
+        for (let j = 1; j <= SAMPLES; j++) {
+            const t = j / SAMPLES, u = 1 - t;
+            push(u * u * x0 + 2 * u * t * qx + t * t * x, u * u * y0 + 2 * u * t * qy + t * t * y, t);
+        }
+    };
+}
+/** A quadratic Bézier with control point (x1, y1), ending at (x, y). */
+export function quadTo(x1, y1, x, y, a, b) {
+    return { cmd: 'Q', d: 'Q' + pt(x1, y1) + ' ' + pt(x, y), x, y, a, b, sample: quadSample(x1, y1, x, y) };
+}
+/** 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 function smoothTo(cx, cy, x, y, a, b) {
+    return { cmd: 'T', d: 'T' + pt(x, y), x, y, a, b, sample: quadSample(cx, cy, x, y) };
+}
+/** 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 function arcTo(r, large, sweep, x, y, a, b) {
+    return {
+        cmd: 'A', d: 'A' + f2(r) + ' ' + f2(r) + ' 0 ' + large + ' ' + sweep + ' ' + pt(x, y), x, y, a, b,
+        sample(x0, y0, push) {
+            // The circle of radius r through both ends, on the side the flags pick.
+            const dx = x - x0, dy = y - y0, d = Math.hypot(dx, dy), h = Math.sqrt(Math.max(0, r * r - (d * d) / 4));
+            let best = null;
+            for (const side of [1, -1]) {
+                const cx = (x0 + x) / 2 - (side * h * dy) / d, cy = (y0 + y) / 2 + (side * h * dx) / d;
+                const t0 = Math.atan2(y0 - cy, x0 - cx), t1 = Math.atan2(y - cy, x - cx);
+                let span = t1 - t0;
+                if (sweep === 1) {
+                    while (span <= 0)
+                        span += 2 * Math.PI;
+                }
+                else {
+                    while (span >= 0)
+                        span -= 2 * Math.PI;
+                }
+                if ((Math.abs(span) > Math.PI) === (large === 1) && !best)
+                    best = { cx, cy, t0, span };
+            }
+            const arc = best ?? { cx: (x0 + x) / 2, cy: (y0 + y) / 2, t0: Math.atan2(y0 - (y0 + y) / 2, x0 - (x0 + x) / 2), span: sweep === 1 ? Math.PI : -Math.PI };
+            const m = Math.max(SAMPLES, Math.ceil(Math.abs(arc.span) / 0.2));
+            for (let j = 1; j <= m; j++) {
+                const t = j / m, q = arc.t0 + arc.span * t;
+                push(j === m ? x : arc.cx + r * Math.cos(q), j === m ? y : arc.cy + r * Math.sin(q), t);
+            }
+        },
+    };
+}
+/** The tangents of a monotone cubic through the values (Fritsch–Carlson), per unit of the index. */
+function monotone(v, n) {
+    const m = new Float64Array(n), s = new Float64Array(n - 1);
+    for (let k = 0; k < n - 1; k++)
+        s[k] = v[k + 1] - v[k];
+    m[0] = s[0];
+    m[n - 1] = s[n - 2];
+    for (let k = 1; k < n - 1; k++)
+        m[k] = s[k - 1] * s[k] <= 0 ? 0 : (s[k - 1] + s[k]) / 2;
+    for (let k = 0; k < n - 1; k++) {
+        if (s[k] === 0) {
+            m[k] = m[k + 1] = 0;
+            continue;
+        }
+        const a = m[k] / s[k], b = m[k + 1] / s[k], q = a * a + b * b;
+        if (q > 9) {
+            const tau = 3 / Math.sqrt(q);
+            m[k] = tau * a * s[k];
+            m[k + 1] = tau * b * s[k];
+        }
+    }
+    return m;
+}
+/** The second derivatives of the natural cubic spline through the values at parameters with these spacings `h`. */
+function natural(v, h, n) {
+    const M = new Float64Array(n);
+    if (n < 3)
+        return M;
+    // Tridiagonal system for the interior second derivatives, by the Thomas algorithm.
+    const diag = new Float64Array(n), rhs = new Float64Array(n);
+    for (let k = 1; k < n - 1; k++) {
+        diag[k] = 2 * (h[k - 1] + h[k]);
+        rhs[k] = 6 * ((v[k + 1] - v[k]) / h[k] - (v[k] - v[k - 1]) / h[k - 1]);
+    }
+    for (let k = 2; k < n - 1; k++) {
+        const w = h[k - 1] / diag[k - 1];
+        diag[k] = diag[k] - w * h[k - 1];
+        rhs[k] = rhs[k] - w * rhs[k - 1];
+    }
+    for (let k = n - 2; k >= 1; k--)
+        M[k] = (rhs[k] - (k < n - 2 ? h[k] * M[k + 1] : 0)) / diag[k];
+    return M;
+}
+/** The runs of points that are real: their pairs, and the index of each one's point in the series. One run per stretch between gaps, or all in one when connecting. */
+function runsOf(points, connect, also) {
+    const { data, count, stride } = points, out = [];
+    const ok = (i) => { const x = data[i * stride], y = data[i * stride + 1]; return Number.isFinite(x) && Number.isFinite(y) && (!also || also(i)); };
+    let run = [], index = [];
+    const end = () => { if (index.length)
+        out.push({ pts: Float64Array.from(run), index }); run = []; index = []; };
+    for (let i = 0; i < count; i++) {
+        if (ok(i)) {
+            run.push(data[i * stride], data[i * stride + 1]);
+            index.push(i);
+        }
+        else if (!connect)
+            end();
+    }
+    end();
+    return out;
+}
+/** The vertices of a run of curves as one buffer, a NaN point after each run, and each vertex's owner. */
+function gather(parts) {
+    let total = 0;
+    for (const p of parts)
+        total += p.owner.length + 1;
+    const data = new Float64Array(2 * total), owner = new Int32Array(total);
+    let k = 0;
+    for (const p of parts) {
+        for (let i = 0; i < p.owner.length; i++, k++) {
+            data[2 * k] = p.pts[2 * i];
+            data[2 * k + 1] = p.pts[2 * i + 1];
+            owner[k] = p.owner[i];
+        }
+        data[2 * k] = data[2 * k + 1] = NaN;
+        owner[k] = -1;
+        k++;
+    }
+    return { line: { data, stride: 2, count: total }, owner };
+}
+/**
+ * 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 class StrokeCurve extends Curve {
+    /**
+     * 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, lead, series) {
+        const n = p.length >> 1;
+        if (n === 0)
+            return '';
+        let d = lead + pt(p[0], p[1]), previous = '';
+        if (n > 1) {
+            for (const c of this.pieces(p, series)) {
+                d += c.cmd === 'L' && previous === 'L' ? ' ' + c.d.slice(1) : c.d;
+                previous = c.cmd;
+            }
+        }
+        return d;
+    }
+    /** 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, series) {
+        const n = p.length >> 1, pts = [], owner = [];
+        if (n === 0)
+            return { pts, owner };
+        pts.push(p[0], p[1]);
+        owner.push(0);
+        if (n === 1)
+            return { pts, owner };
+        let x = p[0], y = p[1];
+        for (const c of this.pieces(p, series)) {
+            c.sample(x, y, (px, py, t) => { pts.push(px, py); owner.push(t < 0.5 ? c.a : c.b); });
+            x = c.x;
+            y = c.y;
+        }
+        return { pts, owner };
+    }
+    line(series) {
+        let d = '';
+        for (const run of runsOf(series.points, series.attrs.gaps === 'connect'))
+            d += this.path(run.pts, 'M', series);
+        return d;
+    }
+    /** Each run of the shape: its top as pairs, the way back along its baseline (reversed), and the series' index of each point. */
+    #runs(series, baseline) {
+        const base = series.baseline(baseline);
+        const real = (i) => { const x = base.data[2 * i], y = base.data[2 * i + 1]; return Number.isFinite(x) && Number.isFinite(y); };
+        return runsOf(series.points, series.attrs.gaps === 'connect', real).map((run) => {
+            const foot = new Float64Array(run.pts.length);
+            run.index.forEach((row, j) => { foot[run.pts.length - 2 - 2 * j] = base.data[2 * row]; foot[run.pts.length - 1 - 2 * j] = base.data[2 * row + 1]; });
+            return { top: run.pts, back: foot, index: run.index };
+        });
+    }
+    area(series, baseline) {
+        let d = '';
+        for (const r of this.#runs(series, baseline))
+            d += this.path(r.top, 'M', series) + this.path(r.back, 'L', series) + 'Z';
+        return d;
+    }
+    #key = '';
+    #value = null;
+    trace(series, baseline) {
+        const key = `${series.projection}|${baseline}|${series.attrs.gaps}|${JSON.stringify(this.attrs)}`;
+        if (key === this.#key)
+            return this.#value;
+        this.#key = key;
+        if (baseline === null) {
+            const parts = runsOf(series.points, series.attrs.gaps === 'connect').map((run) => {
+                const { pts, owner } = this.polyline(run.pts, series);
+                return { pts, owner: owner.map((i) => run.index[i]) };
+            });
+            return (this.#value = { ...gather(parts), base: null });
+        }
+        const tops = [], feet = [];
+        for (const r of this.#runs(series, baseline)) {
+            const t = this.polyline(r.top, series), b = this.polyline(r.back, series);
+            tops.push({ pts: t.pts, owner: t.owner.map((i) => r.index[i]) });
+            // The way back is drawn from the last point to the first; kept here in the direction of the line, so that a vertex lines up with the top's.
+            const forward = [], m = b.pts.length >> 1;
+            for (let i = m - 1; i >= 0; i--)
+                forward.push(b.pts[2 * i], b.pts[2 * i + 1]);
+            feet.push({ pts: forward, owner: b.owner.map(() => 0) });
+        }
+        return (this.#value = { ...gather(tops), base: gather(feet).line });
+    }
+}
+const xs = (p) => { const n = p.length >> 1, a = new Float64Array(n); for (let i = 0; i < n; i++)
+    a[i] = p[2 * i]; return a; };
+const ys = (p) => { const n = p.length >> 1, a = new Float64Array(n); for (let i = 0; i < n; i++)
+    a[i] = p[2 * i + 1]; return a; };
+/** Straight lines to every point after the first. */
+const straight = (p) => { const out = []; for (let i = 1; i < p.length >> 1; i++)
+    out.push(lineTo(p[2 * i], p[2 * i + 1], i - 1, i)); return out; };
+/** The points of `p` extended past both ends by reflection, which leaves the end tangents along the first and last segment. */
+const reflected = (p) => {
+    const n = p.length >> 1;
+    const at = (c) => (i) => (i < 0 ? 2 * p[c] - p[2 + c] : i >= n ? 2 * p[2 * n - 2 + c] - p[2 * n - 4 + c] : p[2 * i + c]);
+    return [at(0), at(1)];
+};
+/** A smooth line that never overshoots the data: a monotone cubic (Fritsch–Carlson). */
+export class MonotoneCurve extends StrokeCurve {
+    pieces(p) {
+        const n = p.length >> 1;
+        if (n === 2)
+            return straight(p);
+        const mx = monotone(xs(p), n), my = monotone(ys(p), n), out = [];
+        for (let k = 0; k < n - 1; k++)
+            out.push(hermiteTo(p, k, mx[k], my[k], mx[k + 1], my[k + 1], 1));
+        return out;
+    }
+}
+/** The natural cubic spline: the smoothest line through the points, which swings past them. */
+export class NaturalCurve extends StrokeCurve {
+    pieces(p) {
+        const n = p.length >> 1;
+        if (n === 2)
+            return straight(p);
+        const h = new Float64Array(n - 1), X = xs(p), Y = ys(p), out = [];
+        // Parameter by the length of the polyline, so that a path which doubles back is as smooth as a function.
+        for (let k = 0; k < n - 1; k++)
+            h[k] = Math.max(1e-6, Math.hypot(X[k + 1] - X[k], Y[k + 1] - Y[k]));
+        const Mx = natural(X, h, n), My = natural(Y, h, n);
+        for (let k = 0; k < n - 1; k++) {
+            const hk = h[k], dx = (X[k + 1] - X[k]) / hk, dy = (Y[k + 1] - Y[k]) / hk;
+            out.push(hermiteTo(p, k, dx - (hk * (2 * Mx[k] + Mx[k + 1])) / 6, dy - (hk * (2 * My[k] + My[k + 1])) / 6, dx + (hk * (Mx[k] + 2 * Mx[k + 1])) / 6, dy + (hk * (My[k] + 2 * My[k + 1])) / 6, hk));
+        }
+        return out;
+    }
+}
+/** A cardinal spline: through every point, with a tangent along the neighbours that `tension` shortens. */
+export class CardinalCurve extends StrokeCurve {
+    pieces(p) {
+        const n = p.length >> 1, c = 1 - (this.attrs.tension ?? 0), [px, py] = reflected(p), out = [];
+        for (let k = 0; k < n - 1; k++) {
+            out.push(hermiteTo(p, k, (c * (px(k + 1) - px(k - 1))) / 2, (c * (py(k + 1) - py(k - 1))) / 2, (c * (px(k + 2) - px(k))) / 2, (c * (py(k + 2) - py(k))) / 2, 1));
+        }
+        return out;
+    }
+}
+/** The Catmull–Rom spline: through every point, centripetal by default so that it neither loops nor cusps when the spacing is uneven. */
+export class CatmullRomCurve extends StrokeCurve {
+    pieces(p) {
+        const n = p.length >> 1, alpha = this.attrs.alpha ?? 0.5, [px, py] = reflected(p), out = [];
+        const knot = (a, b) => Math.pow(Math.hypot(px(b) - px(a), py(b) - py(a)), alpha);
+        for (let k = 0; k < n - 1; k++) {
+            const t01 = knot(k - 1, k), t12 = knot(k, k + 1), t23 = knot(k + 1, k + 2);
+            if (!(t12 > 1e-9) || !(t01 > 1e-9) || !(t23 > 1e-9)) {
+                out.push(lineTo(p[2 * k + 2], p[2 * k + 3], k, k + 1));
+                continue;
+            }
+            const tangent = (v) => {
+                const q0 = v(k - 1), q1 = v(k), q2 = v(k + 1), q3 = v(k + 2);
+                return [
+                    (q1 - q0) / t01 - (q2 - q0) / (t01 + t12) + (q2 - q1) / t12,
+                    (q2 - q1) / t12 - (q3 - q1) / (t12 + t23) + (q3 - q2) / t23,
+                ];
+            };
+            const [ax, bx] = tangent(px), [ay, by] = tangent(py);
+            out.push(hermiteTo(p, k, ax, ay, bx, by, t12));
+        }
+        return out;
+    }
+}
+/** A uniform cubic B-spline, pulled towards the points rather than through them, starting at the first and ending at the last. */
+export class BasisCurve extends StrokeCurve {
+    pieces(p) {
+        const n = p.length >> 1, out = [];
+        const X = (i) => p[2 * Math.min(n - 1, Math.max(0, i))], Y = (i) => p[2 * Math.min(n - 1, Math.max(0, i)) + 1];
+        out.push(lineTo((5 * X(0) + X(1)) / 6, (5 * Y(0) + Y(1)) / 6, 0, 0));
+        for (let j = 0; j < n - 1; j++) {
+            // The control points b, c, e of this piece; it runs from a sixth of the way (a + 4b + c) to the next such place.
+            const bx = X(j), by = Y(j), cx = X(j + 1), cy = Y(j + 1), ex = X(j + 2), ey = Y(j + 2);
+            out.push(cubicTo((2 * bx + cx) / 3, (2 * by + cy) / 3, (bx + 2 * cx) / 3, (by + 2 * cy) / 3, (bx + 4 * cx + ex) / 6, (by + 4 * cy + ey) / 6, j, j + 1));
+        }
+        out.push(lineTo(X(n - 1), Y(n - 1), n - 1, n - 1));
+        return out;
+    }
+}
+/** A level start and end to each segment and an S between: the flow of a bump chart or a sankey. */
+export class BumpCurve extends StrokeCurve {
+    pieces(p, series) {
+        const n = p.length >> 1, out = [];
+        const o = series?.firstAxis.orientation, alongX = (this.attrs.along ?? (o === 'left' || o === 'right' ? 'y' : 'x')) === 'x';
+        for (let k = 0; k < n - 1; k++) {
+            const x0 = p[2 * k], y0 = p[2 * k + 1], x1 = p[2 * k + 2], y1 = p[2 * k + 3];
+            out.push(alongX ? cubicTo((x0 + x1) / 2, y0, (x0 + x1) / 2, y1, x1, y1, k, k + 1) : cubicTo(x0, (y0 + y1) / 2, x1, (y0 + y1) / 2, x1, y1, k, k + 1));
+        }
+        return out;
+    }
+}
+/** Quadratic Béziers with each point as a control point, through the middles of the segments. */
+export class QuadraticCurve extends StrokeCurve {
+    pieces(p) {
+        const n = p.length >> 1;
+        if (n === 2)
+            return straight(p);
+        const X = (i) => p[2 * i], Y = (i) => p[2 * i + 1], out = [];
+        out.push(lineTo((X(0) + X(1)) / 2, (Y(0) + Y(1)) / 2, 0, 0));
+        out.push(quadTo(X(1), Y(1), (X(1) + X(2)) / 2, (Y(1) + Y(2)) / 2, 1, 1));
+        // A smooth quadratic reflects the last control point, which for midpoints is exactly the next data point.
+        for (let k = 2; k < n - 1; k++)
+            out.push(smoothTo(X(k), Y(k), (X(k) + X(k + 1)) / 2, (Y(k) + Y(k + 1)) / 2, k, k));
+        out.push(lineTo(X(n - 1), Y(n - 1), n - 1, n - 1));
+        return out;
+    }
+}
+/** A circular arc between each pair of points. */
+export class ArcCurve extends StrokeCurve {
+    pieces(p) {
+        const n = p.length >> 1, b = this.attrs.bend ?? 0.3, rise = Math.abs(b), out = [];
+        for (let k = 0; k < n - 1; k++) {
+            const x = p[2 * k + 2], y = p[2 * k + 3], chord = Math.hypot(x - p[2 * k], y - p[2 * k + 1]);
+            out.push(!(chord > 1e-9) || rise < 1e-6 ? lineTo(x, y, k, k + 1) : arcTo((chord * (0.25 + rise * rise)) / (2 * rise), rise > 0.5 ? 1 : 0, b > 0 ? 0 : 1, x, y, k, k + 1));
+        }
+        return out;
+    }
+}

package/dist/data.d.ts

@@ -0,0 +1,209 @@
+import { type AnyElement, type BaseAttributes, ChartElement } from './element.ts';
+import type { Extent } from './geometry.ts';
+import type { Series } from './series.ts';
+/** Points in pixel space as a series hands them to planes and renderers: `count` rows of `stride` numbers in `data`. */
+export interface PointBuffer {
+    data: Float64Array;
+    stride: number;
+    count: number;
+}
+/** What a series tells the data about the plot it will draw in, so stages can deliver only what is needed. */
+export interface PlanContext {
+    readonly width: number;
+    readonly height: number;
+    readonly domainRange: Extent;
+    /**
+     * Extra columns to deliver after the domain and the value, in this order: a point is then `2 + channels.length`
+     * numbers wide. A series asks for the channels its renderers bind.
+     */
+    readonly channels: readonly string[];
+    /**
+     * True when the domain is only the order of the points, as in an XY plot where a path wanders across the plane, and
+     * not a position on an axis. Nothing may window or thin such points by pixel column, so a `Decimator` refuses them.
+     * Default false.
+     */
+    readonly sequence?: boolean;
+}
+/**
+ * `extents` has one entry per column: the domain, the value, then each channel.
+ *
+ * `rowOf` says which row of the source's own storage each written point is. It is there when the points *are* the
+ * source's (in place, or sorted into the managed copy) and left out when something made them up (a decimator's
+ * min and max), so that an edit can never be aimed at a row that is not there.
+ */
+export interface FillResult {
+    readonly count: number;
+    readonly extents: readonly Extent[];
+    readonly rowOf?: (index: number) => number;
+}
+/** A promise of points: how much room `fill` may need, and the function that writes them. */
+export interface FillPlan {
+    readonly capacity: number;
+    fill(out: Float64Array): FillResult;
+}
+/** A read-only look at a source's own storage, so a decimator can scan it without copying. */
+export interface PointView {
+    readonly data: ArrayLike<number>;
+    readonly count: number;
+    readonly stride: number;
+    readonly domainOffset: number;
+    readonly valueOffset: number;
+    /** When set, the domain is `start + step * i` and is never read from `data`. */
+    readonly regularDomain: {
+        start: number;
+        step: number;
+    } | null;
+}
+/**
+ * What the type checker knows of the channels a stage offers, so that a series asking for one by name can be checked
+ * against its source. A stage whose channels are not spelled out (`string`) is not checked.
+ */
+export type Offers<Channel extends string> = string extends Channel ? any : {
+    [K in Channel]: true;
+};
+/** What every stage of the data pipeline provides, whether it is a source or a transform. */
+export interface DataStage {
+    /** Increases whenever the data changes. Fills are cached against it. */
+    readonly version: number;
+    readonly pointCount: number;
+    /** The extent of the domain, or null if there are no points. */
+    domain(): Extent | null;
+    /** The extent of every value, whatever part of the domain is being drawn. Null if there are none. */
+    valueExtent(): Extent | null;
+    /** The extent of every value of a channel, whatever part of the domain is being drawn. Null if there are none. */
+    channelExtent(name: string): Extent | null;
+    /** Points always come out ascending in the domain, whatever the storage order was. */
+    plan(context: PlanContext): FillPlan;
+    /**
+     * The points, ascending in the domain, as storage that can be read in place and is valid until the next change.
+     * Null when there is no such storage (generated data, a transform): use `plan` instead.
+     */
+    view?(): PointView | null;
+    /** The channels it can deliver by name, in order: what to ask for to read all of it. Absent or empty when there are none. */
+    readonly channelNames?: readonly string[];
+    /** Optional hint for in-place edits: only [start, end) changed. */
+    invalidateRange?(start: number, end: number): void;
+}
+export interface DataSourceAttributes extends BaseAttributes {
+    /**
+     * The stored points already ascend in the domain. Default false.
+     *
+     * A source always *delivers* ascending points; this says whether it has to arrange that. When false, the source
+     * loads the points once per change into a buffer it owns, drops any with a NaN domain, and sorts them if they are
+     * not already in order. When true that copy is skipped and the data is read where it is, so set it for large
+     * data you know is ordered. Setting it for data that is not ordered draws wrong lines.
+     */
+    isSorted?: boolean;
+    /**
+     * The domain repeats with this period, and the source delivers one more point: the first, again, one period on.
+     * That closes the turn for a plane that wraps (a radar or polar plot) so a line or an area meets itself; `wrap: 6`
+     * for six categories at 0 to 5 puts a copy of the first at 6. The period must reach past the last point. A wrapped
+     * source is always loaded into its own buffer, so `isSorted` only saves it the sort.
+     */
+    wrap?: number;
+}
+/** A source's own sorted copy of its points, valid for one `version`. `extents` has one entry per column. */
+interface ManagedPoints {
+    version: number;
+    data: Float64Array;
+    count: number;
+    stride: number;
+    extents: readonly Extent[];
+    /** The storage row of each sorted point, or null when sorted order is storage order. */
+    rows: Uint32Array | null;
+}
+/** The extent of an empty column: min above max, so any real value replaces it and `min <= max` tests emptiness. */
+export declare const NO_POINTS: Extent;
+/** Shared with sources.ts. Missing values become NaN, which every stage treats as a gap. */
+export declare const num: (v: unknown) => number;
+/** The first and last finite values of `n` readings, which for an ascending domain are its extent. */
+export declare function endsOf(n: number, at: (i: number) => number): Extent | null;
+/**
+ * Everything the contract needs that does not depend on where the numbers are stored: ordering, the managed buffer,
+ * wrapping, extents and caching. A concrete source supplies only `fill`, `scanDomain` and (if it can) `orderedView`.
+ */
+export declare abstract class DataSource<A extends DataSourceAttributes = DataSourceAttributes, Channel extends string = string> extends ChartElement<Series | DataTransform, [], A> implements DataStage {
+    #private;
+    static attrTypes: {
+        isSorted: 3;
+        id: 1;
+        meta: {
+            title: 1;
+            description: 1;
+            role: 1;
+        };
+    };
+    /** Type checking only: the channel names this source offers. Never present at run time. */
+    readonly offers?: Offers<Channel>;
+    private domainCache;
+    private valueCache;
+    private channelCache;
+    /** Increases whenever the data changes. Cached fills are keyed on it. */
+    get version(): number;
+    abstract get pointCount(): number;
+    /**
+     * True when `fill` already writes ascending points, so nothing needs arranging: the data is flagged sorted,
+     * or the source generates it in order. A generated source overrides this.
+     */
+    protected get ordered(): boolean;
+    /** Ordered, and so read where it is stored: not when wrapped, since the extra point has to live somewhere. */
+    private get inPlace();
+    /** The channels this source can deliver, in the order `managed` stores them. Default none. */
+    get channelNames(): readonly string[];
+    /**
+     * Write every point into `out`, in storage order, as the domain, the value and then each of `context.channels`,
+     * and report the extent of every column, NaN skipped. This is the hot loop, so each source writes its own
+     * against its own storage.
+     */
+    protected abstract fill(out: Float64Array, context: PlanContext): FillResult;
+    /**
+     * The extent of the domain of an `ordered` source, or null if there are no points. Only the two ends matter,
+     * so this never scans. Cached per version by `domain()`.
+     */
+    protected abstract scanDomain(): Extent | null;
+    /** An `ordered` source that can be read in place offers its storage here. Default: nothing to offer. */
+    protected orderedView(): PointView | null;
+    /**
+     * The points in a buffer this source owns, ascending, rebuilt lazily after each change. An ordered source is
+     * only copied; any other has NaN-domain points dropped and is sorted (stably) unless it happens to be in order.
+     */
+    protected managed(): ManagedPoints;
+    /** The managed buffer as a view. */
+    protected managedView(): PointView;
+    /** The points ascending in the domain, to read in place; valid until the next change. Null: use `plan`. */
+    view(): PointView | null;
+    /** Any change to the data bumps the version, which is what discards cached fills. */
+    invalidate(): void;
+    /** Cached per version; an in-place source only looks at its two ends, a managed one already knows. */
+    domain(): Extent | null;
+    /**
+     * The extent of all the values, gaps skipped. A scan of the stored points, made once per change and only when asked,
+     * for anything that needs the whole range while drawing only part of it (the limits of a zoom).
+     */
+    valueExtent(): Extent | null;
+    /** Like `valueExtent` for one channel: a scan made once per change and name, for anything that needs the whole range. */
+    channelExtent(name: string): Extent | null;
+    /**
+     * In place: fill straight from storage in the requested column order. Managed: copy the sorted buffer, repacking rows
+     * only when the series wants a different selection of channels than the source stores.
+     */
+    plan(context: PlanContext): FillPlan;
+}
+/** A stage that takes another stage as input: a decimator, a filter, a resampler. It has no storage of its own, so it implements the stage interface directly. */
+export declare abstract class DataTransform<A extends BaseAttributes = BaseAttributes, Children extends readonly AnyElement[] = [source: DataNode], Channel extends string = string> extends ChartElement<Series | DataTransform, Children, A> implements DataStage {
+    /** Type checking only: the channel names this stage offers. Never present at run time. */
+    readonly offers?: Offers<Channel>;
+    abstract get version(): number;
+    abstract get pointCount(): number;
+    /** The channels it delivers by name. Default none; a transform that passes its source's through, or makes its own, says so. */
+    get channelNames(): readonly string[];
+    /** A transform that keeps its output in a typed array may offer it for reading in place. */
+    view?(): PointView | null;
+    abstract domain(): Extent | null;
+    abstract valueExtent(): Extent | null;
+    abstract channelExtent(name: string): Extent | null;
+    abstract plan(context: PlanContext): FillPlan;
+}
+/** A source or a transform. `DataNode<'x'>` is one the type checker knows offers a channel called x. */
+export type DataNode<Channel extends string = string> = DataSource<DataSourceAttributes, Channel> | DataTransform<BaseAttributes, readonly AnyElement[], Channel>;
+export {};