react-cheminfo 0.8.0 → 0.10.0

package/lib/scatter/ui/lassoGesture.d.ts

@@ -0,0 +1,185 @@
+/**
+ * What a lasso is asked for, what it hands back, and the arithmetic behind the
+ * rectangle it is drawn on.
+ *
+ * Kept out of the hook the way `listNavigation` is kept out of its own: where
+ * the pointer is, which modifier wins and how a frame is booked are questions
+ * with one answer each, and none of them needs React to be read or checked.
+ */
+import type { CSSProperties, PointerEvent as ReactPointerEvent } from 'react';
+import type { LassoPath } from '../core/lassoPath.ts';
+import type { ScatterSelectionMode } from '../core/scatterSelection.ts';
+/**
+ * What the transparent rectangle laid over a plot has to carry.
+ *
+ * One rectangle takes every gesture, rather than each dot carrying handlers of
+ * its own: two thousand `<circle>` elements with six listeners each is two
+ * thousand times the work on mount, and a hit test against a coordinate array
+ * is cheaper than one against the DOM. Spread the whole object, and give the
+ * rectangle a fill — a rectangle with none is never hit.
+ */
+export interface ScatterSurfaceProps {
+    /** Starts the drag and claims the pointer for the rest of it. */
+    onPointerDown: (event: ReactPointerEvent<Element>) => void;
+    /** Follows the pointer, at most once a frame. */
+    onPointerMove: (event: ReactPointerEvent<Element>) => void;
+    /** Ends the drag and commits what was drawn. */
+    onPointerUp: (event: ReactPointerEvent<Element>) => void;
+    /** Abandons the drag when the browser takes the pointer away. */
+    onPointerCancel: (event: ReactPointerEvent<Element>) => void;
+    /** Abandons it when the capture is lost for any other reason. */
+    onLostPointerCapture: (event: ReactPointerEvent<Element>) => void;
+    /** Tells a hover card the pointer has left, when no drag is running. */
+    onPointerLeave: (event: ReactPointerEvent<Element>) => void;
+    /** Keeps a finger from scrolling the page, and names the pointer. */
+    style: CSSProperties;
+}
+/** What `useLassoGesture` needs. */
+export interface LassoGestureOptions {
+    /**
+     * Whether a drag draws an outline. The pointer is still followed when it is
+     * off, so a plot with no lasso still has a hover card.
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Whether a finger draws rather than scrolling the page. Off, because a
+     * figure that traps the page scroll on a phone is the worse fault.
+     * @default false
+     */
+    touch?: boolean;
+    /**
+     * How far the pointer moves before a vertex is kept, in pixels.
+     * @default 3
+     */
+    minDistance?: number;
+    /**
+     * Where the rectangle's left edge sits in the space the points were measured
+     * in — the plot's `left`, since a plot is inset by its axes.
+     * @default 0
+     */
+    originX?: number;
+    /**
+     * Where its top edge sits, the plot's `top`.
+     * @default 0
+     */
+    originY?: number;
+    /**
+     * What a drag with no modifier held does to the selection.
+     * @default 'replace'
+     */
+    mode?: ScatterSelectionMode;
+    /**
+     * Called on every frame the outline grew, and once with `null` when the drag
+     * ends — so whatever was drawn from the growing path is cleared by the same
+     * hand that set it.
+     * @default undefined
+     */
+    onDraw?: (path: LassoPath | null, mode: ScatterSelectionMode) => void;
+    /**
+     * Called when a ring was released. The path is reused by the next drag, so
+     * read it before returning.
+     * @default undefined
+     */
+    onComplete?: (path: LassoPath, mode: ScatterSelectionMode) => void;
+    /**
+     * Called instead when the pointer went up having drawn nothing worth
+     * closing — a click, which a scatter reads as picking one point.
+     * @default undefined
+     */
+    onClick?: (x: number, y: number, mode: ScatterSelectionMode) => void;
+    /**
+     * Called with every position the rectangle saw, coalesced to one a frame,
+     * and whether a drag was running. A hover test belongs here, where it pays
+     * the throttle the outline is already paying.
+     * @default undefined
+     */
+    onMove?: (x: number, y: number, drawing: boolean) => void;
+    /**
+     * Called when the pointer leaves with no drag running.
+     * @default undefined
+     */
+    onLeave?: () => void;
+}
+/** A lasso being drawn, or waiting to be. */
+export interface LassoGesture {
+    /** Spread onto the rectangle laid over the plot. */
+    surface: ScatterSurfaceProps;
+    /** Whether a drag is under way. */
+    drawing: boolean;
+    /** The outline so far as an SVG `d`, left open; `''` between drags. */
+    pathData: string;
+    /**
+     * What releasing now would do to the selection. It is reported while the
+     * drag runs, so a caption can say `Adding to the selection` from the moment
+     * Shift goes down rather than after the fact.
+     */
+    mode: ScatterSelectionMode;
+    /** Abandon the drag from outside — what Escape is wired to. */
+    cancel: () => void;
+}
+/** The modifier keys the hand making a gesture is holding. */
+export interface GestureModifiers {
+    /** Whether Alt is down, which always removes. */
+    altKey: boolean;
+    /** Whether Shift is down, which always adds. */
+    shiftKey: boolean;
+}
+/** Where a booked animation frame is remembered between calls. */
+export interface FrameSlot {
+    /** The frame's handle, or `null` when none is booked. */
+    current: number | null;
+}
+/** How far the pointer travels before a vertex is worth keeping, in pixels. */
+export declare const DEFAULT_LASSO_MIN_DISTANCE = 3;
+/** Vertices a stroke needs before it is a ring rather than a click. */
+export declare const MINIMUM_RING_VERTICES = 3;
+/**
+ * The mode a drag is running in, from the keys the hand is holding.
+ *
+ * Alt removes and Shift adds whatever the plot's resting mode is, so both
+ * gestures mean the same thing on every figure. Alt wins a hand holding both,
+ * because taking points out is the more deliberate of the two asks.
+ * @param event - The pointer event, for its modifier keys.
+ * @param resting - What a drag with neither key held does.
+ * @returns The mode a release would use.
+ */
+export declare function modifierMode(event: GestureModifiers, resting: ScatterSelectionMode): ScatterSelectionMode;
+/**
+ * Where the pointer is, in the space the points were measured in.
+ *
+ * Measured from the rectangle rather than from the page and then shifted by
+ * the plot's own corner, so the answer can be compared with a point coordinate
+ * without the caller mapping anything. An element that cannot be measured —
+ * a server render — reports the corner itself rather than throwing.
+ * @param event - The pointer event.
+ * @param originX - The rectangle's left edge in the points' space.
+ * @param originY - Its top edge.
+ * @returns The position, in pixels.
+ */
+export declare function surfacePosition(event: ReactPointerEvent<Element>, originX: number, originY: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Claim the pointer, so a drag that wanders off the figure keeps drawing.
+ * @param event - The pointer event that started the drag.
+ */
+export declare function capturePointer(event: ReactPointerEvent<Element>): void;
+/**
+ * Book a frame to do the work on, unless one is already booked.
+ *
+ * Where there is no `requestAnimationFrame` — a server render, a test — the
+ * work is done at once. Coalescing is a saving, never a requirement, and a
+ * gesture that only worked in a browser with a frame clock would be untestable
+ * as well as fragile.
+ * @param frameRef - Where the booking is held.
+ * @param run - What the frame should do.
+ */
+export declare function scheduleFrame(frameRef: FrameSlot, run: () => void): void;
+/**
+ * Drop a frame that was booked and is no longer wanted.
+ * @param frameRef - Where the booking is held; emptied either way.
+ */
+export declare function dropFrame(frameRef: FrameSlot): void;
+//# sourceMappingURL=lassoGesture.d.ts.map

package/lib/scatter/ui/lassoGesture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lassoGesture.d.ts","sourceRoot":"","sources":["../../../src/scatter/ui/lassoGesture.ts"],"names":[],"mappings":"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"}

package/lib/scatter/ui/lassoGesture.js

@@ -0,0 +1,100 @@
+/**
+ * What a lasso is asked for, what it hands back, and the arithmetic behind the
+ * rectangle it is drawn on.
+ *
+ * Kept out of the hook the way `listNavigation` is kept out of its own: where
+ * the pointer is, which modifier wins and how a frame is booked are questions
+ * with one answer each, and none of them needs React to be read or checked.
+ */
+/** How far the pointer travels before a vertex is worth keeping, in pixels. */
+export const DEFAULT_LASSO_MIN_DISTANCE = 3;
+/** Vertices a stroke needs before it is a ring rather than a click. */
+export const MINIMUM_RING_VERTICES = 3;
+/**
+ * The mode a drag is running in, from the keys the hand is holding.
+ *
+ * Alt removes and Shift adds whatever the plot's resting mode is, so both
+ * gestures mean the same thing on every figure. Alt wins a hand holding both,
+ * because taking points out is the more deliberate of the two asks.
+ * @param event - The pointer event, for its modifier keys.
+ * @param resting - What a drag with neither key held does.
+ * @returns The mode a release would use.
+ */
+export function modifierMode(event, resting) {
+    if (event.altKey)
+        return 'remove';
+    if (event.shiftKey)
+        return 'add';
+    return resting;
+}
+/**
+ * Where the pointer is, in the space the points were measured in.
+ *
+ * Measured from the rectangle rather than from the page and then shifted by
+ * the plot's own corner, so the answer can be compared with a point coordinate
+ * without the caller mapping anything. An element that cannot be measured —
+ * a server render — reports the corner itself rather than throwing.
+ * @param event - The pointer event.
+ * @param originX - The rectangle's left edge in the points' space.
+ * @param originY - Its top edge.
+ * @returns The position, in pixels.
+ */
+export function surfacePosition(event, originX, originY) {
+    const target = event.currentTarget;
+    if (typeof target?.getBoundingClientRect !== 'function') {
+        return { x: originX, y: originY };
+    }
+    const box = target.getBoundingClientRect();
+    return {
+        x: event.clientX - box.left + originX,
+        y: event.clientY - box.top + originY,
+    };
+}
+/**
+ * Claim the pointer, so a drag that wanders off the figure keeps drawing.
+ * @param event - The pointer event that started the drag.
+ */
+export function capturePointer(event) {
+    const target = event.currentTarget;
+    if (typeof target?.setPointerCapture !== 'function')
+        return;
+    try {
+        target.setPointerCapture(event.pointerId);
+    }
+    catch {
+        // The pointer was already gone; the drag ends through the same one path.
+    }
+}
+/**
+ * Book a frame to do the work on, unless one is already booked.
+ *
+ * Where there is no `requestAnimationFrame` — a server render, a test — the
+ * work is done at once. Coalescing is a saving, never a requirement, and a
+ * gesture that only worked in a browser with a frame clock would be untestable
+ * as well as fragile.
+ * @param frameRef - Where the booking is held.
+ * @param run - What the frame should do.
+ */
+export function scheduleFrame(frameRef, run) {
+    if (frameRef.current !== null)
+        return;
+    if (typeof requestAnimationFrame === 'function') {
+        frameRef.current = requestAnimationFrame(run);
+    }
+    else {
+        run();
+    }
+}
+/**
+ * Drop a frame that was booked and is no longer wanted.
+ * @param frameRef - Where the booking is held; emptied either way.
+ */
+export function dropFrame(frameRef) {
+    if (frameRef.current === null)
+        return;
+    if (typeof cancelAnimationFrame === 'function') {
+        cancelAnimationFrame(frameRef.current);
+    }
+    frameRef.current = null;
+}
+//# sourceMappingURL=lassoGesture.js.map

package/lib/scatter/ui/lassoGesture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lassoGesture.js","sourceRoot":"","sources":["../../../src/scatter/ui/lassoGesture.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAqIH,+EAA+E;AAC/E,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC;AAE5C,uEAAuE;AACvE,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC;AAEvC;;;;;;;;;GASG;AACH,MAAM,UAAU,YAAY,CAC1B,KAAuB,EACvB,OAA6B;IAE7B,IAAI,KAAK,CAAC,MAAM;QAAE,OAAO,QAAQ,CAAC;IAClC,IAAI,KAAK,CAAC,QAAQ;QAAE,OAAO,KAAK,CAAC;IACjC,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe,CAC7B,KAAiC,EACjC,OAAe,EACf,OAAe;IAEf,MAAM,MAAM,GAAG,KAAK,CAAC,aAAa,CAAC;IACnC,IAAI,OAAO,MAAM,EAAE,qBAAqB,KAAK,UAAU,EAAE,CAAC;QACxD,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC;IACpC,CAAC;IACD,MAAM,GAAG,GAAG,MAAM,CAAC,qBAAqB,EAAE,CAAC;IAC3C,OAAO;QACL,CAAC,EAAE,KAAK,CAAC,OAAO,GAAG,GAAG,CAAC,IAAI,GAAG,OAAO;QACrC,CAAC,EAAE,KAAK,CAAC,OAAO,GAAG,GAAG,CAAC,GAAG,GAAG,OAAO;KACrC,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,KAAiC;IAC9D,MAAM,MAAM,GAAG,KAAK,CAAC,aAAa,CAAC;IACnC,IAAI,OAAO,MAAM,EAAE,iBAAiB,KAAK,UAAU;QAAE,OAAO;IAC5D,IAAI,CAAC;QACH,MAAM,CAAC,iBAAiB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAC5C,CAAC;IAAC,MAAM,CAAC;QACP,yEAAyE;IAC3E,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAAC,QAAmB,EAAE,GAAe;IAChE,IAAI,QAAQ,CAAC,OAAO,KAAK,IAAI;QAAE,OAAO;IACtC,IAAI,OAAO,qBAAqB,KAAK,UAAU,EAAE,CAAC;QAChD,QAAQ,CAAC,OAAO,GAAG,qBAAqB,CAAC,GAAG,CAAC,CAAC;IAChD,CAAC;SAAM,CAAC;QACN,GAAG,EAAE,CAAC;IACR,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,SAAS,CAAC,QAAmB;IAC3C,IAAI,QAAQ,CAAC,OAAO,KAAK,IAAI;QAAE,OAAO;IACtC,IAAI,OAAO,oBAAoB,KAAK,UAAU,EAAE,CAAC;QAC/C,oBAAoB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IACzC,CAAC;IACD,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC;AAC1B,CAAC"}

package/lib/scatter/ui/scatterGroupSpread.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Every group's outline over every pair of axes, measured once.
+ *
+ * A pair grid asks the same question of a group thirty-six times, and calling
+ * `confidenceEllipse` per cell would gather that group's points into a fresh
+ * array of objects each time — n² allocations to draw n axes, over the same
+ * samples. The averages and the pairwise covariances say everything an outline
+ * needs, they come out of two passes over the scores read where they stand,
+ * and a cell then reads four numbers out of the block.
+ */
+import type { MatrixLike } from '../../chart/core/matrix.ts';
+import type { ConfidenceEllipse, EllipseSize } from '../core/confidenceEllipse.ts';
+/** How every group is spread over the axes a grid lays out. */
+export interface ScatterGroupSpread {
+    /** How many leading axes each block covers. */
+    axes: number;
+    /** How many groups it holds. */
+    groups: number;
+    /** How many rows went into each group, in group order. */
+    counts: Int32Array;
+    /** Each group's average along each axis, at `group * axes + axis`. */
+    means: Float64Array;
+    /**
+     * How each group varies between two axes, at `(group * axes + a) * axes + b`
+     * and again at the transposed position, so a cell reads either way round.
+     */
+    covariances: Float64Array;
+    /** How far out an outline is drawn, in standard deviations. */
+    standardDeviations: number;
+    /** How many rows a group needs before it is outlined at all. */
+    minimumPoints: number;
+}
+/** How {@link scatterGroupSpread} measures the groups. */
+export interface ScatterGroupSpreadOptions {
+    /** The coordinates: one row per sample, one column per axis, read in place. */
+    scores: MatrixLike;
+    /** Which group each row belongs to; a row outside the range is left out. */
+    groupOf: ArrayLike<number>;
+    /** How many groups there are. */
+    groups: number;
+    /** How many leading axes to measure over. */
+    axes: number;
+    /**
+     * How large the outlines are drawn.
+     * @default { kind: 'coverage', probability: 0.95 }
+     */
+    size?: EllipseSize;
+    /**
+     * How many rows a group needs before it is outlined at all.
+     * @default 3
+     */
+    minimumPoints?: number;
+}
+/**
+ * Measure every group over every laid-out axis, in two passes.
+ *
+ * A row missing a value in any one of the axes is left out of the group
+ * altogether rather than only out of the cells that use that axis: an outline
+ * that quietly covered a different set of samples in each cell would make the
+ * grid disagree with itself, and a reader comparing two cells has no way to
+ * see it. The spread uses the `n - 1` divisor, as `confidenceEllipse` does, so
+ * a group outlined here and the same group outlined on the map come out the
+ * same size.
+ * @param options - See {@link ScatterGroupSpreadOptions}.
+ * @returns The block, whose `counts` are what a caller reports as too small to outline.
+ */
+export declare function scatterGroupSpread(options: ScatterGroupSpreadOptions): ScatterGroupSpread;
+/**
+ * One group's outline for one pair of axes, in data units.
+ *
+ * The two-by-two block cut out of the covariances is a covariance in its own
+ * right — that is what makes the grid affordable — so it decomposes into
+ * radii and a tilt exactly as a pair measured on its own would.
+ * @param spread - The block, from {@link scatterGroupSpread}.
+ * @param group - Which group.
+ * @param xAxis - The axis along the foot of the cell.
+ * @param yAxis - The axis up its side.
+ * @returns The outline, or `null` when the group is too small to have a shape, when either axis is outside the block, or when the requested size is unbounded.
+ */
+export declare function scatterPairEllipse(spread: ScatterGroupSpread, group: number, xAxis: number, yAxis: number): ConfidenceEllipse | null;
+//# sourceMappingURL=scatterGroupSpread.d.ts.map

package/lib/scatter/ui/scatterGroupSpread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scatterGroupSpread.d.ts","sourceRoot":"","sources":["../../../src/scatter/ui/scatterGroupSpread.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EACV,iBAAiB,EAEjB,WAAW,EACZ,MAAM,8BAA8B,CAAC;AAMtC,+DAA+D;AAC/D,MAAM,WAAW,kBAAkB;IACjC,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,MAAM,EAAE,UAAU,CAAC;IACnB,sEAAsE;IACtE,KAAK,EAAE,YAAY,CAAC;IACpB;;;OAGG;IACH,WAAW,EAAE,YAAY,CAAC;IAC1B,+DAA+D;IAC/D,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gEAAgE;IAChE,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,0DAA0D;AAC1D,MAAM,WAAW,yBAAyB;IACxC,+EAA+E;IAC/E,MAAM,EAAE,UAAU,CAAC;IACnB,4EAA4E;IAC5E,OAAO,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAC3B,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,yBAAyB,GACjC,kBAAkB,CAgEpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,iBAAiB,GAAG,IAAI,CAqB1B"}

package/lib/scatter/ui/scatterGroupSpread.js

@@ -0,0 +1,147 @@
+/**
+ * Every group's outline over every pair of axes, measured once.
+ *
+ * A pair grid asks the same question of a group thirty-six times, and calling
+ * `confidenceEllipse` per cell would gather that group's points into a fresh
+ * array of objects each time — n² allocations to draw n axes, over the same
+ * samples. The averages and the pairwise covariances say everything an outline
+ * needs, they come out of two passes over the scores read where they stand,
+ * and a cell then reads four numbers out of the block.
+ */
+import { ellipseAxes, ellipseStandardDeviations, } from "../core/confidenceEllipse.js";
+/**
+ * Measure every group over every laid-out axis, in two passes.
+ *
+ * A row missing a value in any one of the axes is left out of the group
+ * altogether rather than only out of the cells that use that axis: an outline
+ * that quietly covered a different set of samples in each cell would make the
+ * grid disagree with itself, and a reader comparing two cells has no way to
+ * see it. The spread uses the `n - 1` divisor, as `confidenceEllipse` does, so
+ * a group outlined here and the same group outlined on the map come out the
+ * same size.
+ * @param options - See {@link ScatterGroupSpreadOptions}.
+ * @returns The block, whose `counts` are what a caller reports as too small to outline.
+ */
+export function scatterGroupSpread(options) {
+    const { scores, groupOf, size = DEFAULT_SIZE, minimumPoints = 3 } = options;
+    const groups = Math.max(0, Math.trunc(options.groups));
+    const axes = Math.max(0, Math.min(Math.trunc(options.axes), scores.columns));
+    const counts = new Int32Array(groups);
+    const means = new Float64Array(groups * axes);
+    const covariances = new Float64Array(groups * axes * axes);
+    const spread = {
+        axes,
+        groups,
+        counts,
+        means,
+        covariances,
+        standardDeviations: ellipseStandardDeviations(size),
+        minimumPoints,
+    };
+    if (groups === 0 || axes === 0)
+        return spread;
+    for (let row = 0; row < scores.rows; row++) {
+        const group = groupAt(groupOf, row, groups);
+        if (group < 0 || !finiteRow(scores, row, axes))
+            continue;
+        counts[group] = (counts[group] ?? 0) + 1;
+        const base = group * axes;
+        for (let axis = 0; axis < axes; axis++) {
+            means[base + axis] = (means[base + axis] ?? 0) + scores.get(row, axis);
+        }
+    }
+    for (let group = 0; group < groups; group++) {
+        const count = counts[group] ?? 0;
+        if (count === 0)
+            continue;
+        const base = group * axes;
+        for (let axis = 0; axis < axes; axis++) {
+            means[base + axis] = (means[base + axis] ?? 0) / count;
+        }
+    }
+    // One scratch row of deviations, reused for every sample: the alternative is
+    // reading each value twice per pair, which is axes² reads instead of axes.
+    const away = new Float64Array(axes);
+    for (let row = 0; row < scores.rows; row++) {
+        const group = groupAt(groupOf, row, groups);
+        if (group < 0 || !finiteRow(scores, row, axes))
+            continue;
+        const base = group * axes;
+        for (let axis = 0; axis < axes; axis++) {
+            away[axis] = scores.get(row, axis) - (means[base + axis] ?? 0);
+        }
+        const block = group * axes * axes;
+        for (let a = 0; a < axes; a++) {
+            const first = away[a] ?? 0;
+            for (let b = 0; b < axes; b++) {
+                const cell = block + a * axes + b;
+                covariances[cell] = (covariances[cell] ?? 0) + first * (away[b] ?? 0);
+            }
+        }
+    }
+    for (let group = 0; group < groups; group++) {
+        const divisor = (counts[group] ?? 0) - 1;
+        if (divisor < 1)
+            continue;
+        const block = group * axes * axes;
+        for (let cell = 0; cell < axes * axes; cell++) {
+            covariances[block + cell] = (covariances[block + cell] ?? 0) / divisor;
+        }
+    }
+    return spread;
+}
+/**
+ * One group's outline for one pair of axes, in data units.
+ *
+ * The two-by-two block cut out of the covariances is a covariance in its own
+ * right — that is what makes the grid affordable — so it decomposes into
+ * radii and a tilt exactly as a pair measured on its own would.
+ * @param spread - The block, from {@link scatterGroupSpread}.
+ * @param group - Which group.
+ * @param xAxis - The axis along the foot of the cell.
+ * @param yAxis - The axis up its side.
+ * @returns The outline, or `null` when the group is too small to have a shape, when either axis is outside the block, or when the requested size is unbounded.
+ */
+export function scatterPairEllipse(spread, group, xAxis, yAxis) {
+    const { axes, groups, counts, means, covariances } = spread;
+    const { minimumPoints, standardDeviations } = spread;
+    if (group < 0 || group >= groups)
+        return null;
+    if (xAxis < 0 || yAxis < 0 || xAxis >= axes || yAxis >= axes)
+        return null;
+    const count = counts[group] ?? 0;
+    if (count < Math.max(2, minimumPoints))
+        return null;
+    const base = group * axes;
+    const block = group * axes * axes;
+    const covariance = {
+        xx: covariances[block + xAxis * axes + xAxis] ?? 0,
+        xy: covariances[block + xAxis * axes + yAxis] ?? 0,
+        yy: covariances[block + yAxis * axes + yAxis] ?? 0,
+    };
+    const { rx, ry, angle } = ellipseAxes(covariance, standardDeviations);
+    const cx = means[base + xAxis] ?? 0;
+    const cy = means[base + yAxis] ?? 0;
+    if (!Number.isFinite(rx) || !Number.isFinite(ry))
+        return null;
+    if (!Number.isFinite(cx) || !Number.isFinite(cy))
+        return null;
+    return { cx, cy, rx, ry, angle, count, covariance };
+}
+/** What a group is outlined at when the caller says nothing. */
+const DEFAULT_SIZE = { kind: 'coverage', probability: 0.95 };
+function groupAt(groupOf, row, groups) {
+    const raw = groupOf[row];
+    if (raw === undefined || !Number.isFinite(raw))
+        return -1;
+    const group = Math.trunc(raw);
+    return group < 0 || group >= groups ? -1 : group;
+}
+function finiteRow(scores, row, axes) {
+    for (let axis = 0; axis < axes; axis++) {
+        if (!Number.isFinite(scores.get(row, axis)))
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=scatterGroupSpread.js.map

package/lib/scatter/ui/scatterGroupSpread.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scatterGroupSpread.js","sourceRoot":"","sources":["../../../src/scatter/ui/scatterGroupSpread.ts"],"names":[],"mappings":"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"}

package/lib/scatter/ui/scatterLabelBoxes.d.ts

@@ -0,0 +1,94 @@
+/**
+ * How much room a word takes on the plot, and what is already written near a
+ * place a word is about to go.
+ *
+ * A label has no size until a browser has laid it out, and the placing has to
+ * happen before anything is drawn — so the width is estimated from the string
+ * rather than measured. The estimate is deliberately generous: two words that
+ * are believed wider than they are stay further apart than they had to, which
+ * a reader never notices, while two believed narrower overlap, which is the
+ * whole fault being fixed here.
+ *
+ * The field is a uniform grid rather than a list because a map may carry two
+ * thousand names: testing each candidate against every word already placed is
+ * the one part of the placing that grows with the square of the cloud, and a
+ * grid turns it back into a handful of comparisons.
+ */
+/** A rectangle in the frame's pixels. */
+export interface LabelBox {
+    /** Left edge. */
+    left: number;
+    /** Top edge. */
+    top: number;
+    /** Right edge. */
+    right: number;
+    /** Bottom edge. */
+    bottom: number;
+}
+/**
+ * How wide a word will be drawn, in pixels, without laying it out.
+ *
+ * The average glyph of the interface's sans is around 0.55 em and its bold
+ * around 0.6, but a name is not average text: `XTC0240` is all caps and
+ * digits, which are the widest glyphs in the font. The figures below are those
+ * upper widths rather than the average, so the answer errs long for a name and
+ * only slightly long for a sentence.
+ * @param text - What the label says.
+ * @param fontSize - What it is set in, in pixels.
+ * @param bold - Whether it is the heavier weight, which is wider.
+ * @returns The width, in pixels.
+ */
+export declare function labelBoxWidth(text: string, fontSize: number, bold?: boolean): number;
+/**
+ * How tall a line of text is, in pixels — the size it is set in plus the space
+ * a reader needs between one word and the next to read them as two words.
+ * @param fontSize - What the label is set in, in pixels.
+ * @returns The height, in pixels.
+ */
+export declare function labelBoxHeight(fontSize: number): number;
+/**
+ * Whether two rectangles share any pixel at all.
+ * @param one - One rectangle.
+ * @param other - The other.
+ * @returns Whether they touch.
+ */
+export declare function labelBoxesOverlap(one: LabelBox, other: LabelBox): boolean;
+/**
+ * The words already written, and whether there is room for one more.
+ *
+ * Each rectangle is filed under every cell of a coarse grid it touches, so
+ * asking about a candidate only compares it with the words that could
+ * possibly be in its way. The grid is built and thrown away inside one
+ * placing pass; nothing outside this file holds onto it.
+ */
+export declare class LabelBoxField {
+    #private;
+    /**
+     * Nothing has been written yet.
+     * @param cell - Side of one grid square, in pixels. It wants to be a few
+     * label-widths across: too small and a wide name is filed under a dozen
+     * cells, too large and every comparison comes back.
+     * @default 96
+     */
+    constructor(cell?: number);
+    /**
+     * Whether a rectangle can be written without touching one already there.
+     * @param box - Where the word would go.
+     * @returns Whether the place is free.
+     */
+    fits(box: LabelBox): boolean;
+    /**
+     * Keep a rectangle, so nothing placed afterwards lands on it.
+     * @param box - Where the word went.
+     */
+    add(box: LabelBox): void;
+}
+/**
+ * What a sample's name is set in, in pixels, and what a group's is. The layer
+ * draws at these sizes and the placing keeps room at them: two numbers that
+ * drift apart are two words that overlap.
+ */
+export declare const SCATTER_LABEL_SIZE = 10;
+/** What a group's name is set in — see {@link SCATTER_LABEL_SIZE}. */
+export declare const SCATTER_GROUP_LABEL_SIZE = 12;
+//# sourceMappingURL=scatterLabelBoxes.d.ts.map

package/lib/scatter/ui/scatterLabelBoxes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scatterLabelBoxes.d.ts","sourceRoot":"","sources":["../../../src/scatter/ui/scatterLabelBoxes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,yCAAyC;AACzC,MAAM,WAAW,QAAQ;IACvB,iBAAiB;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,kBAAkB;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,IAAI,UAAQ,GACX,MAAM,CAER;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAOzE;AAED;;;;;;;GAOG;AACH,qBAAa,aAAa;;IAIxB;;;;;;OAMG;gBACS,IAAI,SAAe;IAI/B;;;;OAIG;IACH,IAAI,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO;IAmB5B;;;OAGG;IACH,GAAG,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI;CAgBzB;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAErC,sEAAsE;AACtE,eAAO,MAAM,wBAAwB,KAAK,CAAC"}