inkplot 0.0.0-stage → 1.0.0-beta.1

package/dist/hit.js

@@ -0,0 +1,428 @@
+const DEFAULT_RADIUS = 10;
+/** The least a series' hit radius is while the last input was a finger: a fingertip is not a mouse pointer. */
+const COARSE_RADIUS = 24;
+/** Distance from (x, y) to a point, with a NaN coordinate of the pointer leaving that direction out. */
+function between(px, py, x, y) {
+    const dx = x !== x ? 0 : px - x, dy = y !== y ? 0 : py - y;
+    return Math.hypot(dx, dy);
+}
+/** The nearest drawn point; points that are gaps (NaN) are skipped. Null when there is none, or both coordinates are NaN. */
+export function nearestPoint(points, x, y) {
+    if (x !== x && y !== y)
+        return null;
+    const { data, count, stride } = points;
+    let best = -1, bestD = Infinity;
+    for (let i = 0, k = 0; k < count; k++, i += stride) {
+        const px = data[i], py = data[i + 1];
+        if (px !== px || py !== py)
+            continue;
+        const d = between(px, py, x, y);
+        if (d < bestD) {
+            bestD = d;
+            best = k;
+        }
+    }
+    return best < 0 ? null : { index: best, distance: bestD };
+}
+/** The distance to the nearest point of the polyline through the points (a gap breaks it), and the nearer end of that segment. */
+export function nearestSegment(points, x, y) {
+    if (x !== x || y !== y)
+        return nearestPoint(points, x, y);
+    const { data, count, stride } = points;
+    let best = -1, bestD = Infinity;
+    for (let k = 0, i = 0; k < count; k++, i += stride) {
+        const ax = data[i], ay = data[i + 1];
+        if (ax !== ax || ay !== ay)
+            continue;
+        // A point on its own (or the end of a run) is still something to hit.
+        const own = Math.hypot(ax - x, ay - y);
+        if (own < bestD) {
+            bestD = own;
+            best = k;
+        }
+        if (k + 1 >= count)
+            continue;
+        const bx = data[i + stride], by = data[i + stride + 1];
+        if (bx !== bx || by !== by)
+            continue;
+        const sx = bx - ax, sy = by - ay, len2 = sx * sx + sy * sy;
+        const t = len2 > 0 ? Math.max(0, Math.min(1, ((x - ax) * sx + (y - ay) * sy) / len2)) : 0;
+        const d = Math.hypot(ax + t * sx - x, ay + t * sy - y);
+        if (d < bestD) {
+            bestD = d;
+            best = t < 0.5 ? k : k + 1;
+        }
+    }
+    return best < 0 ? null : { index: best, distance: bestD };
+}
+/**
+ * Whether (x, y) is inside the shape that a run of points makes with its baseline (the same points, placed against the
+ * baseline value, which `base` holds one row each for). Runs are the stretches between gaps, each its own shape. The
+ * nearest point of that run is returned when it is, else null.
+ */
+export function insideArea(points, base, x, y) {
+    if (x !== x || y !== y)
+        return null;
+    const { data, count, stride } = points, b = base.data, bs = base.stride;
+    const valid = (k) => data[k * stride] === data[k * stride] && data[k * stride + 1] === data[k * stride + 1] && b[k * bs + 1] === b[k * bs + 1];
+    for (let from = 0; from < count;) {
+        if (!valid(from)) {
+            from++;
+            continue;
+        }
+        let to = from;
+        while (to + 1 < count && valid(to + 1))
+            to++;
+        // Even-odd ray casting over the run forward and its baseline back.
+        const n = to - from + 1;
+        const vx = (j) => (j < n ? data[(from + j) * stride] : b[(to - (j - n)) * bs]);
+        const vy = (j) => (j < n ? data[(from + j) * stride + 1] : b[(to - (j - n)) * bs + 1]);
+        let inside = false;
+        for (let j = 0, prev = 2 * n - 1; j < 2 * n; prev = j++) {
+            const yj = vy(j), yp = vy(prev), xj = vx(j), xp = vx(prev);
+            if ((yj > y) !== (yp > y) && x < ((xp - xj) * (y - yj)) / (yp - yj) + xj)
+                inside = !inside;
+        }
+        if (inside) {
+            let best = from, bestD = Infinity;
+            for (let k = from; k <= to; k++) {
+                const d = Math.hypot(data[k * stride] - x, data[k * stride + 1] - y);
+                if (d < bestD) {
+                    bestD = d;
+                    best = k;
+                }
+            }
+            return best;
+        }
+        from = to + 1;
+    }
+    return null;
+}
+/**
+ * The shape the pointer is inside (distance 0), else the one whose outline is nearest, by the shape's index. Shapes
+ * made of NaN are left out. A NaN coordinate of the pointer means "ignore this direction", and the shapes' own points
+ * then stand for them, as for any other mode.
+ */
+export function nearestShape(shapes, points, x, y) {
+    if (x !== x || y !== y)
+        return nearestPoint(points, x, y);
+    const { data, perShape: m, count } = shapes;
+    let best = -1, bestD = Infinity;
+    for (let k = 0; k < count; k++) {
+        const at = k * m * 2;
+        if (data[at] !== data[at] || data[at + 1] !== data[at + 1])
+            continue;
+        // Quick out: a shape whose bounding box is farther than the best so far cannot be nearer.
+        let x0 = Infinity, x1 = -Infinity, y0 = Infinity, y1 = -Infinity;
+        for (let j = 0; j < m; j++) {
+            const px = data[at + 2 * j], py = data[at + 2 * j + 1];
+            if (px < x0)
+                x0 = px;
+            if (px > x1)
+                x1 = px;
+            if (py < y0)
+                y0 = py;
+            if (py > y1)
+                y1 = py;
+        }
+        if (Math.hypot(Math.max(x0 - x, 0, x - x1), Math.max(y0 - y, 0, y - y1)) >= bestD)
+            continue;
+        let inside = false, edge = Infinity;
+        for (let j = 0, prev = m - 1; j < m; prev = j++) {
+            const ax = data[at + 2 * prev], ay = data[at + 2 * prev + 1], bx = data[at + 2 * j], by = data[at + 2 * j + 1];
+            if ((by > y) !== (ay > y) && x < ((ax - bx) * (y - by)) / (ay - by) + bx)
+                inside = !inside;
+            const sx = bx - ax, sy = by - ay, len2 = sx * sx + sy * sy;
+            const t = len2 > 0 ? Math.max(0, Math.min(1, ((x - ax) * sx + (y - ay) * sy) / len2)) : 0;
+            const d = Math.hypot(ax + t * sx - x, ay + t * sy - y);
+            if (d < edge)
+                edge = d;
+        }
+        const d = inside ? 0 : edge;
+        if (d < bestD) {
+            bestD = d;
+            best = k;
+        }
+    }
+    return best < 0 ? null : { index: best, distance: bestD };
+}
+/** Where the runs of a path are: each stretch between NaN points, as the index of its first vertex and one past its last. */
+function runsIn(path) {
+    const out = [], { data, count, stride } = path;
+    let from = -1;
+    for (let k = 0; k <= count; k++) {
+        const real = k < count && data[k * stride] === data[k * stride] && data[k * stride + 1] === data[k * stride + 1];
+        if (real && from < 0)
+            from = k;
+        else if (!real && from >= 0) {
+            out.push([from, k]);
+            from = -1;
+        }
+    }
+    return out;
+}
+/**
+ * Whether (x, y) is inside a shape a trace draws: each run of its line closed back along the same run of its baseline.
+ * The point it belongs to is the one owning the nearest vertex of the line in that run, else null.
+ */
+export function insideTrace(trace, x, y) {
+    const base = trace.base;
+    if (!base || x !== x || y !== y)
+        return null;
+    const tops = runsIn(trace.line), feet = runsIn(base), a = trace.line, b = base;
+    for (let r = 0; r < tops.length && r < feet.length; r++) {
+        const [t0, t1] = tops[r], [f0, f1] = feet[r], n = t1 - t0, m = f1 - f0, total = n + m;
+        // The line forward, then the baseline back.
+        const vx = (j) => (j < n ? a.data[(t0 + j) * a.stride] : b.data[(f1 - 1 - (j - n)) * b.stride]);
+        const vy = (j) => (j < n ? a.data[(t0 + j) * a.stride + 1] : b.data[(f1 - 1 - (j - n)) * b.stride + 1]);
+        let inside = false;
+        for (let j = 0, prev = total - 1; j < total; prev = j++) {
+            const yj = vy(j), yp = vy(prev), xj = vx(j), xp = vx(prev);
+            if ((yj > y) !== (yp > y) && x < ((xp - xj) * (y - yj)) / (yp - yj) + xj)
+                inside = !inside;
+        }
+        if (inside) {
+            let best = t0, bestD = Infinity;
+            for (let k = t0; k < t1; k++) {
+                const d = Math.hypot(a.data[k * a.stride] - x, a.data[k * a.stride + 1] - y);
+                if (d < bestD) {
+                    bestD = d;
+                    best = k;
+                }
+            }
+            return trace.owner[best];
+        }
+    }
+    return null;
+}
+/** The nearest point under `mode` ('line' or 'area') to a path a renderer traces, by the point each vertex belongs to. */
+export function nearestTraced(trace, mode, x, y) {
+    if (mode === 'area') {
+        const inside = insideTrace(trace, x, y);
+        if (inside !== null)
+            return { index: inside, distance: 0 };
+    }
+    const found = nearestSegment(trace.line, x, y);
+    return found && { index: trace.owner[found.index], distance: found.distance };
+}
+/** The nearest point under `mode`; `base` is the baseline for an area (ignored otherwise). */
+export function nearest(points, mode, base, x, y) {
+    if (mode === 'point')
+        return nearestPoint(points, x, y);
+    if (mode === 'area' && base) {
+        const inside = insideArea(points, base(), x, y);
+        if (inside !== null)
+            return { index: inside, distance: 0 };
+    }
+    return nearestSegment(points, x, y);
+}
+// ─── Series and planes ───
+/** The hit for drawn point `index` of a series, with the pointer `distance` away. */
+export function pointHit(series, index, distance = 0) { return hitAt(series, index, distance); }
+function hitAt(series, index, distance) {
+    const d = series.drawn;
+    if (!d)
+        return null;
+    const { raw, stride, points } = d, names = d.channels, bound = names.length, at = index * stride, channels = {};
+    for (let k = 0; k < bound; k++)
+        channels[names[k]] = raw[at + stride - bound + k];
+    const row = d.rowOf?.(index);
+    // In a stack the point is drawn above its own value by the layers below it.
+    const own = raw[at + d.secondColumn], lift = d.top && d.additive ? d.top[index] - own : NaN;
+    return {
+        series, plane: d.plane, index, ...(row === undefined || row < 0 ? {} : { row }), ...(lift === lift ? { lift } : {}),
+        first: raw[at + d.firstColumn], second: raw[at + d.secondColumn], channels,
+        px: points.data[index * points.stride], py: points.data[index * points.stride + 1], distance,
+    };
+}
+/**
+ * The nearest drawn point of a series to a position in plot pixels, within `maxDistance` (default: its `hit` radius), as
+ * its `hit` mode measures it. A NaN for `x` or `y` leaves that direction out, so `hitTest(series, x, NaN, Infinity)` is
+ * the point nearest in x whatever its height. Null if nothing is near enough, or the series takes no hits.
+ */
+export function hitTest(series, x, y, maxDistance) {
+    const h = series.attrs.hit, d = series.drawn;
+    if (h === false || !d || d.points.count === 0)
+        return null;
+    const o = typeof h === 'string' ? { mode: h } : h ?? {};
+    const mode = o.mode ?? series.hitHint ?? 'point';
+    const tracedMode = mode === 'line' || mode === 'area' ? mode : null;
+    // A path a renderer traces (steps, curves) is what is measured, but a pointer with a coordinate left out measures to points.
+    const traced = tracedMode && x === x && y === y ? series.trace() : null;
+    const found = mode === 'shape'
+        ? (() => { const g = series.shapes(); return g ? nearestShape(g, d.points, x, y) : nearestPoint(d.points, x, y); })()
+        : traced && tracedMode
+            ? nearestTraced(traced, tracedMode, x, y)
+            : nearest(d.points, mode, mode === 'area' ? () => series.baseline(o.baseline ?? 0) : null, x, y);
+    const radius = maxDistance ?? (series.chart?.input?.coarse ? Math.max(o.radius ?? DEFAULT_RADIUS, COARSE_RADIUS) : o.radius ?? DEFAULT_RADIUS);
+    if (!found || !(found.distance <= radius))
+        return null;
+    return hitAt(series, found.index, found.distance);
+}
+/**
+ * The nearest point of any series in the plane that takes hits, within each series' own radius, by that series' `hit`
+ * mode. A tie goes to the series drawn last, which is the one on top.
+ */
+export function hitPlane(plane, x, y) {
+    const series = plane.series;
+    let best = null;
+    for (let i = series.length - 1; i >= 0; i--) {
+        const h = hitTest(series[i], x, y);
+        if (h && (!best || h.distance < best.distance))
+            best = h;
+    }
+    return best;
+}
+/**
+ * The nearest point of every series that takes hits, topmost first. `radius` replaces each series' own, and is unlimited
+ * by default, so `hitAll(plane, x, NaN)` is each series at the pointer's x: what a crosshair tooltip lists.
+ */
+export function hitAll(plane, x, y, radius = Infinity) {
+    const out = [];
+    const series = plane.series;
+    for (let i = series.length - 1; i >= 0; i--) {
+        const h = hitTest(series[i], x, y, radius);
+        if (h)
+            out.push(h);
+    }
+    return out;
+}
+/**
+ * The point of every series that is nearest the pointer *along the first axis*, whatever its distance across: what a
+ * reading shared by all series, such as a crosshair tooltip, lists. It is measured in the axis' own terms and not in
+ * pixels, so it is right wherever the plane puts that axis: across a Cartesian plane, up one whose domain is vertical, and
+ * round a radial plane, where the nearest point is the one nearest in angle (and a full turn wraps, so a pointer just
+ * before the start of the sweep finds the last points). Topmost series first. Series that take no hits are left out.
+ */
+export function hitAcross(plane, x, y) {
+    const out = [], series = plane.series;
+    for (let i = series.length - 1; i >= 0; i--) {
+        const s = series[i], d = s.drawn;
+        if (s.attrs.hit === false || !d || d.points.count === 0)
+            continue;
+        const a = s.firstAxis, b = s.secondAxis, target = a.fractionOf(plane.unplace(x, y, a, b)[0]);
+        if (target !== target)
+            continue;
+        const wraps = plane.cyclic(a), { raw, stride, firstColumn, secondColumn } = d;
+        let best = -1, bestD = Infinity;
+        for (let k = 0, at = 0; k < d.points.count; k++, at += stride) {
+            const v = raw[at + firstColumn], w = raw[at + secondColumn];
+            if (v !== v || w !== w)
+                continue;
+            let gap = Math.abs(a.fractionOf(v) - target);
+            if (wraps) {
+                gap -= Math.floor(gap);
+                if (gap > 0.5)
+                    gap = 1 - gap;
+            }
+            if (gap < bestD) {
+                bestD = gap;
+                best = k;
+            }
+        }
+        if (best < 0)
+            continue;
+        const px = d.points.data[best * d.points.stride], py = d.points.data[best * d.points.stride + 1];
+        const h = hitAt(s, best, Math.hypot(px - x, py - y));
+        if (h)
+            out.push(h);
+    }
+    return out;
+}
+/**
+ * Where a series' line is at position `first` of its first axis, read as a straight line between the two drawn points
+ * either side of it, in data terms (so it is exact for a `LinePath` on a linear scale, and may sit off a curve or a line
+ * drawn another way: see the tooltip's `interpolate`). Only a domain series has one; others, a series that takes no
+ * hits, a position outside the data and one beside a gap give null. The hit is `interpolated`: its `index` and `row`
+ * are the nearer of the two points, and `px`, `py` are where the line is.
+ */
+export function interpolate(series, first) {
+    const d = series.drawn;
+    if (!d || !d.alongDomain || series.attrs.hit === false)
+        return null;
+    const { raw, stride: rs, plane } = d, n = d.points.count;
+    if (n < 2 || !(first >= raw[0] && first <= raw[(n - 1) * rs]))
+        return null;
+    // The last point at or before `first`, found by halving: the domain ascends.
+    let lo = 0, hi = n - 1;
+    while (hi - lo > 1) {
+        const mid = (lo + hi) >> 1;
+        if (raw[mid * rs] <= first)
+            lo = mid;
+        else
+            hi = mid;
+    }
+    const d0 = raw[lo * rs], d1 = raw[hi * rs], v0 = raw[lo * rs + 1], v1 = raw[hi * rs + 1];
+    // In a stack the line is drawn through the stacked values, though it reads as the series' own.
+    const tops = d.top, p0 = tops ? tops[lo] : v0, p1 = tops ? tops[hi] : v1;
+    // On a point exactly, that point is the answer, even at the end of a run with a gap after it.
+    const onPoint = first === d0 && v0 === v0;
+    if (!onPoint && (v0 !== v0 || v1 !== v1))
+        return null;
+    const traced = onPoint ? null : series.trace();
+    if (traced)
+        return interpolateTraced(series, first, traced);
+    const t = onPoint || !(d1 > d0) ? 0 : (first - d0) / (d1 - d0), value = onPoint ? v0 : v0 + t * (v1 - v0);
+    const plotted = onPoint ? p0 : p0 + t * (p1 - p0);
+    const buf = new Float64Array([first, plotted]), a = series.firstAxis, b = series.secondAxis;
+    a.normalize(buf, 1, 2, 0);
+    b.normalize(buf, 1, 2, 1);
+    plane.place({ data: buf, stride: 2, count: 1 }, a, b);
+    const near = hitAt(series, t < 0.5 ? lo : hi, 0);
+    return near && { ...near, first, second: value, px: buf[0], py: buf[1], interpolated: true };
+}
+/**
+ * A reading between two points of a series whose renderer draws something other than straight lines through them: where a
+ * line across the plot at `first` (a spoke on a polar plane) crosses the traced path, read back into data. The value is the
+ * path's own there, less what a stack lays under it, so a step reads as its level and a curve as the height it is drawn at.
+ */
+function interpolateTraced(series, first, trace) {
+    const d = series.drawn;
+    if (!d)
+        return null;
+    const { plane, raw, stride: rs } = d, a = series.firstAxis, b = series.secondAxis;
+    // The line at `first` across the second axis, in pixels.
+    const probe = new Float64Array([a.fractionOf(first), 0, a.fractionOf(first), 1]);
+    plane.place({ data: probe, stride: 2, count: 2 }, a, b);
+    const rx = probe[2] - probe[0], ry = probe[3] - probe[1];
+    const { data, count, stride } = trace.line, eps = 1e-9;
+    for (let k = 0; k + 1 < count; k++) {
+        const ax = data[k * stride], ay = data[k * stride + 1], bx = data[(k + 1) * stride], by = data[(k + 1) * stride + 1];
+        if (ax !== ax || ay !== ay || bx !== bx || by !== by)
+            continue;
+        const sx = bx - ax, sy = by - ay, cross = rx * sy - ry * sx;
+        if (Math.abs(cross) < 1e-12)
+            continue; // parallel to the probe: its ends are met by the pieces either side
+        const qx = ax - probe[0], qy = ay - probe[1];
+        const along = (qx * sy - qy * sx) / cross, u = (qx * ry - qy * rx) / cross; // along the probe, and along this piece
+        if (along < -eps || along > 1 + eps || u < -eps || u > 1 + eps)
+            continue;
+        const px = ax + u * sx, py = ay + u * sy, oa = trace.owner[k], ob = trace.owner[k + 1];
+        const plotted = plane.unplace(px, py, a, b)[1];
+        const own = (i) => raw[i * rs + d.secondColumn];
+        let value = plotted;
+        if (d.top && oa >= 0 && ob >= 0) {
+            // In a stack the path is drawn at the stacked value, which reads as the series' own: take off what is under it.
+            if (d.additive) {
+                const sa = d.top[oa] - own(oa), sb = d.top[ob] - own(ob);
+                value = plotted - (sa + u * (sb - sa));
+            }
+            else
+                value = own(oa) + u * (own(ob) - own(oa));
+        }
+        const near = hitAt(series, u < 0.5 ? oa : ob, 0);
+        return near && { ...near, first, second: value, px, py, interpolated: true };
+    }
+    return null;
+}
+/** Every series' line read at the pointer, topmost first: `interpolate` at the pointer's place along each series' first axis. */
+export function interpolateAll(plane, x, y) {
+    const out = [];
+    const series = plane.series;
+    for (let i = series.length - 1; i >= 0; i--) {
+        const s = series[i], h = interpolate(s, plane.unplace(x, y, s.firstAxis, s.secondAxis)[0]);
+        if (h)
+            out.push(h);
+    }
+    return out;
+}

package/dist/index.d.ts

@@ -0,0 +1,73 @@
+/**
+ * inkplot.
+ *
+ * Conventions
+ *  - Erasable TypeScript only, so Node can run it directly.
+ *  - Members are `private` unless another class genuinely needs them. Where elements have to talk to
+ *    each other (a plane driving its series, a series driving its axes) the methods are public, named
+ *    without an underscore, and documented as protocol under an "Engine protocol" comment.
+ *  - A parent declares its children as a tuple type, so order and arity are checked by the compiler.
+ *  - Options that are declared and not yet supported (`bind` on a line, area or bar) throw when used, via stub.ts.
+ */
+export { type Extent, type Insets, type LayoutRequest, type Rect, type Side, type Size } from './geometry.ts';
+export { type ArrangeEvent, type AttachEvent, type ChartEvent, type ChartEventInit, type ChartKeyEvent, type ChartPointerEvent, EVENT_ARRANGE, EVENT_ATTACH, EVENT_FOCUS, EVENT_HOVER, EVENT_KEY, EVENT_MEASURE, EVENT_PAINT, EVENT_POINTER, EventBase, type FocusEvent, type Hit, type HoverEvent, type MeasureEvent, type PaintEvent } from './events.ts';
+export { type FontSpec, type Platform, type PlatformNode, type RawFocus, type RawKey, type RawPointer, StringPlatform, type SvgTag, type TextMeasurer, type Unsubscribe, estimateTextWidth } from './platform.ts';
+export { type DOMContainer, DOMPlatform, type DOMPlatformOptions } from './dom-platform.ts';
+export { type Counters, type NodeOptions, type Placement, type StageName, Surface } from './surface.ts';
+export { type AnyElement, type BaseAttributes, ChartElement, type ElementArgs, type ElementClass, type ElementRef, type FixedIndex, type Meta, type VariadicChild, childrenOfType, closestAncestorOfType, descendantsOfType, findById, firstDescendantOfType, resolveRef, walk } from './element.ts';
+export { IntlTimeScale, type IntlTimeScaleAttributes } from './time-intl.ts';
+export { TemporalTimeScale, type TemporalLike, type TemporalTimeScaleAttributes, type ZonedLike } from './time-temporal.ts';
+export { TimeScale, type TimeRank, type TimeScaleAttributes, type TimeUnit } from './time.ts';
+export { Scale, type ScaleAttributes } from './scale.ts';
+export { BandScale, type BandScaleAttributes, LinearScale, LogScale, type LogScaleAttributes, SqrtScale } from './scales.ts';
+export { Dimension, type DimensionAttributes, type Tick } from './dimension.ts';
+export { Axis, type AxisAttributes, type AxisOrientation, type CartesianOrientation, type PolarOrientation, type Ruler, type TitleSpot } from './axis.ts';
+export { applyText } from './text.ts';
+export { type AxisMetrics, type BaseTheme, type LineProps, type MarkerMetrics, type Roots, type SelectorName, type Selectors, type ShapeProps, type TextProps, type Theme, extendTheme, resolveStyle } from './theme.ts';
+export { darkTheme, lightTheme } from './themes.ts';
+export { type DataNode, DataSource, type DataSourceAttributes, type DataStage, DataTransform, type FillPlan, type FillResult, type PlanContext, type PointBuffer, type PointView } from './data.ts';
+export { type Column, CompositeDataSource, type CompositeDataSourceAttributes, type Field, FlatDataSource, type FlatDataSourceAttributes, ObjectDataSource, type ObjectDataSourceAttributes, SyntheticDataSource, type SyntheticDataSourceAttributes } from './sources.ts';
+export { DecimationKernel, Decimator, type DecimatorAttributes, LttbKernel, M4Kernel, MinMaxKernel, type ReduceResult, StrideKernel } from './decimation.ts';
+export { AreaPath, type AreaPathAttributes, LinePath, type LinePathAttributes, type PolygonSet, type ResolvedBinding, type Trace, SeriesRenderer, type SeriesRendererAttributes, type StyleBindable } from './renderer.ts';
+export { Curve, type CurveAttributes, LinearCurve, areaOutline, polyline } from './curve.ts';
+export { ArcCurve, type ArcCurveAttributes, BasisCurve, BumpCurve, type BumpCurveAttributes, CardinalCurve, type CardinalCurveAttributes, CatmullRomCurve, type CatmullRomCurveAttributes, MonotoneCurve, NaturalCurve, type Piece, type Push, QuadraticCurve, StrokeCurve, arcTo, cubicTo, hermiteTo, lineTo, quadTo, smoothTo } from './curves.ts';
+export { StepCurve, type StepCurveAttributes, type StepMode, type Stepped, stepLines } from './steps.ts';
+export { BoxPath, type BoxPathAttributes } from './boxplot.ts';
+export { BoxStats, type BoxStatsAttributes } from './stats.ts';
+export { quantile } from './quantile.ts';
+export { Density, type DensityAttributes } from './density.ts';
+export { ErrorBand, type ErrorBandAttributes, ErrorBars, type ErrorBarsAttributes } from './errors.ts';
+export { barShift } from './bars.ts';
+export { BarLinePath, type BarLinePathAttributes, BarPath, type BarPathAttributes, BarRenderer, type BarRendererAttributes, type BarOptions, barShapes, stemLines } from './bars.ts';
+export { Stack, type StackAttributes, type StackAlign, type StackMode, type Layout, alignRows, layOut } from './stack.ts';
+export { DomainSeries, type DomainSeriesAttributes, type Drawn, type Rows, Series, type SeriesGroup, type StackLayer, seriesOf, paintSample, type SampleCache, type SeriesAttributes, type SeriesChildren, XYSeries, type XYSeriesAttributes } from './series.ts';
+export { CartesianPlane, type CartesianPlaneAttributes, Plane, type PlaneAttributes, type PlaneChildMap, type PlaneChildren } from './plane.ts';
+export { PolarPlane, type PolarPlaneAttributes, RadarPlane, type RadarPlaneAttributes, RadialPlane, type RadialPlaneAttributes } from './radial.ts';
+export { type PngHost, type PngOptions, svgToPng, toPng } from './png.ts';
+export { BoxZoom, type BoxZoomAttributes } from './boxzoom.ts';
+export { Brush, type BrushAttributes, type BrushRange, type BrushSelection } from './brush.ts';
+export { DEFAULT_PANZOOM_KEYS, PanZoom, type PanZoomAction, type PanZoomAttributes, type PanZoomKeys } from './panzoom.ts';
+export { type ChartFacts, ChartSummary, type ChartSummaryAttributes, englishSummary } from './summary.ts';
+export { type AriaDefaults, hideFromAssistive, writeAria } from './aria.ts';
+export { drawFocusRing, makeTabStop, pressesButton } from './focus.ts';
+export { type Table, type TableOptions, readTable } from './table.ts';
+export { InputHost, inputOf } from './input.ts';
+export { Chart, type ChartAttributes, type Describer, type ChartChildMap, type ChartChildren, type FlushStats, type SvgOptions, toSvgString } from './chart.ts';
+export { type Binding, type Bindings, ColorAxis, type ColorAxisAttributes, type ColorRampName, MappedDimension, type MappedDimensionAttributes, SizeAxis, type SizeAxisAttributes } from './mapped.ts';
+export { Legend, type LegendAttributes } from './legend.ts';
+export { ColorKey, Key, SizeKey, type ColorKeyAttributes, type KeyAttributes, type KeyOrientation, type SizeKeyAttributes } from './key.ts';
+export { Trendline, LinearTrend, PolynomialTrend, SinusoidalTrend, LoessTrend, type LinearTrendAttributes, type LoessTrendAttributes, type PolynomialTrendAttributes, type SinusoidalTrendAttributes, type TrendFit, type TrendModel, type TrendlineAttributes } from './trend.ts';
+export { HeatMap, type HeatMapAttributes, type HeatMapBindable } from './heatmap.ts';
+export { CircleMarker, CrossMarker, DotMarker, LineMarker, Marker, PlusMarker, ShapeMarker, SquareMarker, type DotMarkerAttributes, type DotMarkerBindable, type LineMarkerBindable, type MarkerAttributes, type MarkerStyle, type ShapeMarkerBindable } from './marker.ts';
+export { type HitMode, type HitOptions, hitAcross, hitAll, hitPlane, hitTest, insideArea, insideTrace, interpolate, interpolateAll, nearest, nearestPoint, nearestSegment, nearestShape, nearestTraced, pointHit } from './hit.ts';
+export { type DragInfo, PointerListener, type PointerListenerAttributes, type PointerInfo } from './pointer.ts';
+export { type CalloutLook, calloutSize, clearCallout, paintCallout } from './callout.ts';
+export { Cursor, type CursorAction, type CursorAttributes, type CursorChild, type CursorChildMap, type CursorKeys, type CursorState, DEFAULT_CURSOR_KEYS } from './cursor.ts';
+export { Crosshair, type CrosshairAttributes } from './crosshair.ts';
+export { ChartTitle, type ChartTitleAttributes, ChartTooltip, type ChartTooltipAttributes, type TitleRole } from './furniture.ts';
+export { CalloutAnnotation, type CalloutAnnotationAttributes, LineAnnotation, type LineAnnotationAttributes, type LineAnnotationCommon } from './annotation.ts';
+export { LINE_HEIGHT, measureBlock, paintLines } from './text.ts';
+export { type ElementJSON, type ElementRegistry, Refs, type SerializeOptions, applyJSON, fromJSON, toJSON } from './serialize.ts';
+export { registry } from './registry.ts';
+export { type LineSeriesOptions, lineSeries } from './simple.ts';
+export { AUTO, BOOLEAN, NUMBER, STRING, type AttrTypes, type AttrTypesFor, type Coerce, type ExpandOptions, expandAttributes } from './attrs.ts';

package/dist/index.js

@@ -0,0 +1,73 @@
+/**
+ * inkplot.
+ *
+ * Conventions
+ *  - Erasable TypeScript only, so Node can run it directly.
+ *  - Members are `private` unless another class genuinely needs them. Where elements have to talk to
+ *    each other (a plane driving its series, a series driving its axes) the methods are public, named
+ *    without an underscore, and documented as protocol under an "Engine protocol" comment.
+ *  - A parent declares its children as a tuple type, so order and arity are checked by the compiler.
+ *  - Options that are declared and not yet supported (`bind` on a line, area or bar) throw when used, via stub.ts.
+ */
+export {} from './geometry.js';
+export { EVENT_ARRANGE, EVENT_ATTACH, EVENT_FOCUS, EVENT_HOVER, EVENT_KEY, EVENT_MEASURE, EVENT_PAINT, EVENT_POINTER, EventBase } from './events.js';
+export { StringPlatform, estimateTextWidth } from './platform.js';
+export { DOMPlatform } from './dom-platform.js';
+export { Surface } from './surface.js';
+export { ChartElement, childrenOfType, closestAncestorOfType, descendantsOfType, findById, firstDescendantOfType, resolveRef, walk } from './element.js';
+export { IntlTimeScale } from './time-intl.js';
+export { TemporalTimeScale } from './time-temporal.js';
+export { TimeScale } from './time.js';
+export { Scale } from './scale.js';
+export { BandScale, LinearScale, LogScale, SqrtScale } from './scales.js';
+export { Dimension } from './dimension.js';
+export { Axis } from './axis.js';
+export { applyText } from './text.js';
+export { extendTheme, resolveStyle } from './theme.js';
+export { darkTheme, lightTheme } from './themes.js';
+export { DataSource, DataTransform } from './data.js';
+export { CompositeDataSource, FlatDataSource, ObjectDataSource, SyntheticDataSource } from './sources.js';
+export { DecimationKernel, Decimator, LttbKernel, M4Kernel, MinMaxKernel, StrideKernel } from './decimation.js';
+export { AreaPath, LinePath, SeriesRenderer } from './renderer.js';
+export { Curve, LinearCurve, areaOutline, polyline } from './curve.js';
+export { ArcCurve, BasisCurve, BumpCurve, CardinalCurve, CatmullRomCurve, MonotoneCurve, NaturalCurve, QuadraticCurve, StrokeCurve, arcTo, cubicTo, hermiteTo, lineTo, quadTo, smoothTo } from './curves.js';
+export { StepCurve, stepLines } from './steps.js';
+export { BoxPath } from './boxplot.js';
+export { BoxStats } from './stats.js';
+export { quantile } from './quantile.js';
+export { Density } from './density.js';
+export { ErrorBand, ErrorBars } from './errors.js';
+export { barShift } from './bars.js';
+export { BarLinePath, BarPath, BarRenderer, barShapes, stemLines } from './bars.js';
+export { Stack, alignRows, layOut } from './stack.js';
+export { DomainSeries, Series, seriesOf, paintSample, XYSeries } from './series.js';
+export { CartesianPlane, Plane } from './plane.js';
+export { PolarPlane, RadarPlane, RadialPlane } from './radial.js';
+export { svgToPng, toPng } from './png.js';
+export { BoxZoom } from './boxzoom.js';
+export { Brush } from './brush.js';
+export { DEFAULT_PANZOOM_KEYS, PanZoom } from './panzoom.js';
+export { ChartSummary, englishSummary } from './summary.js';
+export { hideFromAssistive, writeAria } from './aria.js';
+export { drawFocusRing, makeTabStop, pressesButton } from './focus.js';
+export { readTable } from './table.js';
+export { InputHost, inputOf } from './input.js';
+export { Chart, toSvgString } from './chart.js';
+export { ColorAxis, MappedDimension, SizeAxis } from './mapped.js';
+export { Legend } from './legend.js';
+export { ColorKey, Key, SizeKey } from './key.js';
+export { Trendline, LinearTrend, PolynomialTrend, SinusoidalTrend, LoessTrend } from './trend.js';
+export { HeatMap } from './heatmap.js';
+export { CircleMarker, CrossMarker, DotMarker, LineMarker, Marker, PlusMarker, ShapeMarker, SquareMarker } from './marker.js';
+export { hitAcross, hitAll, hitPlane, hitTest, insideArea, insideTrace, interpolate, interpolateAll, nearest, nearestPoint, nearestSegment, nearestShape, nearestTraced, pointHit } from './hit.js';
+export { PointerListener } from './pointer.js';
+export { calloutSize, clearCallout, paintCallout } from './callout.js';
+export { Cursor, DEFAULT_CURSOR_KEYS } from './cursor.js';
+export { Crosshair } from './crosshair.js';
+export { ChartTitle, ChartTooltip } from './furniture.js';
+export { CalloutAnnotation, LineAnnotation } from './annotation.js';
+export { LINE_HEIGHT, measureBlock, paintLines } from './text.js';
+export { Refs, applyJSON, fromJSON, toJSON } from './serialize.js';
+export { registry } from './registry.js';
+export { lineSeries } from './simple.js';
+export { AUTO, BOOLEAN, NUMBER, STRING, expandAttributes } from './attrs.js';

package/dist/input.d.ts

@@ -0,0 +1,42 @@
+import type { AnyElement } from './element.ts';
+import type { Chart } from './chart.ts';
+import type { PlatformNode, RawFocus, RawKey, RawPointer, Unsubscribe } from './platform.ts';
+export declare class InputHost {
+    #private;
+    /** True while the last pointer input came from a finger, which hits use to be more forgiving. */
+    coarse: boolean;
+    constructor(chart: Chart);
+    /** Listen to the chart's platform. Called by `inputOf`; a platform with no input of a kind simply gives none. */
+    start(): void;
+    /** Stop listening and forget everything held: `Chart.detach()` calls it. */
+    stop(): void;
+    /**
+     * Ask for HOVER events (where the pointer is in a plane) for as long as the returned function has not been called.
+     * Elements outside the plane that follow the pointer (a tooltip) subscribe when they attach.
+     */
+    watchPointer(element: AnyElement): Unsubscribe;
+    /**
+     * Ask for POINTER events in the chart's own pixels (not a plane's), for elements that are not in a plane and take
+     * input of their own: a legend's entries. Set `handled` on one to keep the planes from also acting on it. Returns the
+     * way to stop.
+     */
+    watchInput(element: AnyElement): Unsubscribe;
+    /**
+     * Make a node reachable by keyboard: give it a `tabindex` (0 for a place in the tab order, -1 to be focusable by script
+     * only) and say which element it belongs to, which then gets its KEY and FOCUS events. Call again with the same node
+     * freely.
+     */
+    focusable(element: AnyElement, node: PlatformNode): void;
+    /** Say something to a screen reader, if the platform has one to tell. */
+    speak(text: string): void;
+    /** Move keyboard focus to a node an element made `focusable`. Does nothing on a platform without focus. */
+    focus(node: PlatformNode): void;
+    /** One raw pointer: to what listens outside planes first, then to the plane it is over. True when something used it. */
+    route(p: RawPointer): boolean;
+    /** A key on a focused node, to the element that made the node focusable. */
+    routeKey(k: RawKey, node: PlatformNode): boolean;
+    /** Focus entering or leaving a node, to its owner. */
+    routeFocus(f: RawFocus): void;
+}
+/** The chart's input host, made and started on the first ask. Elements that take input call this as they attach. */
+export declare function inputOf(chart: Chart): InputHost;