react-cheminfo 0.8.0 → 0.10.0

package/lib/scatter/core/polygon.d.ts

@@ -0,0 +1,58 @@
+import type { PixelBounds, ScreenPoints } from './screenPoints.ts';
+/**
+ * Whether a point falls inside a polygon.
+ *
+ * A ray cast from the point towards growing x, counting the edges it crosses:
+ * an odd count is inside, an even one is outside. Both tests that decide a
+ * crossing are half-open, and that is what settles the boundary. An edge is
+ * only considered for the ys it spans from its lower end up to, but not
+ * including, its upper end; and the crossing has to sit strictly beyond the
+ * point. So on the square `(0,0) (10,0) (10,10) (0,10)` the two edges meeting
+ * at `(0,0)` count as inside — `(5,0)` and `(0,5)` are in — while the two
+ * meeting at `(10,10)` count as outside, and `(5,10)` and `(10,5)` are out. Of
+ * the four corners only `(0,0)` is inside; `(10,0)`, `(0,10)` and `(10,10)`
+ * are not.
+ *
+ * The asymmetry is the point of the convention rather than an accident of it:
+ * it is what stops two polygons sharing an edge from both claiming the samples
+ * that lie along it, and what keeps a point from toggling in and out as a
+ * lasso is dragged a hundredth of a pixel.
+ * @param x - Horizontal position of the point, in pixels.
+ * @param y - Vertical position of the point, in pixels.
+ * @param xs - Horizontal position of each vertex, in order around the ring; the ring is closed for you.
+ * @param ys - Vertical position of each vertex, in the same order.
+ * @param vertexCount - How many leading entries of the two arrays are vertices, so that a growing buffer can be passed whole. Their common length when omitted.
+ * @returns Whether the point is inside; always `false` for fewer than three vertices, since nothing thinner than a triangle holds anything.
+ */
+export declare function pointInPolygon(x: number, y: number, xs: Float64Array, ys: Float64Array, vertexCount?: number): boolean;
+/**
+ * The rectangle a polygon's vertices span.
+ * @param xs - Horizontal position of each vertex.
+ * @param ys - Vertical position of each vertex.
+ * @param vertexCount - How many leading entries are vertices. Their common length when omitted.
+ * @returns The rectangle, or `null` when no vertex has two finite coordinates. Vertices that do not are left out rather than poisoning the bounds with a `NaN`.
+ */
+export declare function polygonBounds(xs: Float64Array, ys: Float64Array, vertexCount?: number): PixelBounds | null;
+/**
+ * Which of many points fall inside a polygon.
+ *
+ * Each point is measured against the polygon's rectangle first, which is four
+ * comparisons and rejects nearly every point of a cloud that a lasso has
+ * enclosed a corner of; only the survivors pay for a walk over every edge. The
+ * saving is the whole reason the prefilter is here: a released lasso has a
+ * vertex for every few pixels the pointer travelled, so the unfiltered cost is
+ * the point count times a few hundred, per drag, on the frame the user is
+ * waiting for.
+ *
+ * Nothing is allocated per point. The rectangle is computed once, the answer
+ * is written into the mask, and the mask itself is reused when the caller
+ * hands one of the right size back.
+ * @param points - Where every point sits on screen.
+ * @param xs - Horizontal position of each vertex.
+ * @param ys - Vertical position of each vertex.
+ * @param vertexCount - How many leading entries are vertices. Their common length when omitted.
+ * @param into - A mask to write into, so a drag does not allocate one per frame. It is used only when it already has one entry per point; otherwise a new one is allocated, because silently answering about a different number of points is worse than the allocation.
+ * @returns One entry per point, `1` for inside and `0` for outside. All zeros for fewer than three vertices.
+ */
+export declare function pointsInPolygon(points: ScreenPoints, xs: Float64Array, ys: Float64Array, vertexCount?: number, into?: Uint8Array): Uint8Array;
+//# sourceMappingURL=polygon.d.ts.map

package/lib/scatter/core/polygon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon.d.ts","sourceRoot":"","sources":["../../../src/scatter/core/polygon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,YAAY,EAChB,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAwBT;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,YAAY,EAChB,WAAW,CAAC,EAAE,MAAM,GACnB,WAAW,GAAG,IAAI,CAmBpB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,YAAY,EACpB,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,YAAY,EAChB,WAAW,CAAC,EAAE,MAAM,EACpB,IAAI,CAAC,EAAE,UAAU,GAChB,UAAU,CAyBZ"}

package/lib/scatter/core/polygon.js

@@ -0,0 +1,140 @@
+/**
+ * Whether a point falls inside a polygon.
+ *
+ * A ray cast from the point towards growing x, counting the edges it crosses:
+ * an odd count is inside, an even one is outside. Both tests that decide a
+ * crossing are half-open, and that is what settles the boundary. An edge is
+ * only considered for the ys it spans from its lower end up to, but not
+ * including, its upper end; and the crossing has to sit strictly beyond the
+ * point. So on the square `(0,0) (10,0) (10,10) (0,10)` the two edges meeting
+ * at `(0,0)` count as inside — `(5,0)` and `(0,5)` are in — while the two
+ * meeting at `(10,10)` count as outside, and `(5,10)` and `(10,5)` are out. Of
+ * the four corners only `(0,0)` is inside; `(10,0)`, `(0,10)` and `(10,10)`
+ * are not.
+ *
+ * The asymmetry is the point of the convention rather than an accident of it:
+ * it is what stops two polygons sharing an edge from both claiming the samples
+ * that lie along it, and what keeps a point from toggling in and out as a
+ * lasso is dragged a hundredth of a pixel.
+ * @param x - Horizontal position of the point, in pixels.
+ * @param y - Vertical position of the point, in pixels.
+ * @param xs - Horizontal position of each vertex, in order around the ring; the ring is closed for you.
+ * @param ys - Vertical position of each vertex, in the same order.
+ * @param vertexCount - How many leading entries of the two arrays are vertices, so that a growing buffer can be passed whole. Their common length when omitted.
+ * @returns Whether the point is inside; always `false` for fewer than three vertices, since nothing thinner than a triangle holds anything.
+ */
+export function pointInPolygon(x, y, xs, ys, vertexCount) {
+    const count = usableVertexCount(xs, ys, vertexCount);
+    if (count < 3)
+        return false;
+    if (!Number.isFinite(x) || !Number.isFinite(y))
+        return false;
+    let previousX = xs[count - 1];
+    let previousY = ys[count - 1];
+    if (previousX === undefined || previousY === undefined)
+        return false;
+    let inside = false;
+    for (let index = 0; index < count; index++) {
+        const currentX = xs[index];
+        const currentY = ys[index];
+        if (currentX === undefined || currentY === undefined)
+            break;
+        if (currentY > y !== previousY > y) {
+            const crossing = ((previousX - currentX) * (y - currentY)) / (previousY - currentY) +
+                currentX;
+            if (x < crossing)
+                inside = !inside;
+        }
+        previousX = currentX;
+        previousY = currentY;
+    }
+    return inside;
+}
+/**
+ * The rectangle a polygon's vertices span.
+ * @param xs - Horizontal position of each vertex.
+ * @param ys - Vertical position of each vertex.
+ * @param vertexCount - How many leading entries are vertices. Their common length when omitted.
+ * @returns The rectangle, or `null` when no vertex has two finite coordinates. Vertices that do not are left out rather than poisoning the bounds with a `NaN`.
+ */
+export function polygonBounds(xs, ys, vertexCount) {
+    const count = usableVertexCount(xs, ys, vertexCount);
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    let bounded = false;
+    for (let index = 0; index < count; index++) {
+        const vertexX = xs[index];
+        const vertexY = ys[index];
+        if (vertexX === undefined || vertexY === undefined)
+            break;
+        if (!Number.isFinite(vertexX) || !Number.isFinite(vertexY))
+            continue;
+        if (vertexX < minX)
+            minX = vertexX;
+        if (vertexX > maxX)
+            maxX = vertexX;
+        if (vertexY < minY)
+            minY = vertexY;
+        if (vertexY > maxY)
+            maxY = vertexY;
+        bounded = true;
+    }
+    return bounded ? { minX, minY, maxX, maxY } : null;
+}
+/**
+ * Which of many points fall inside a polygon.
+ *
+ * Each point is measured against the polygon's rectangle first, which is four
+ * comparisons and rejects nearly every point of a cloud that a lasso has
+ * enclosed a corner of; only the survivors pay for a walk over every edge. The
+ * saving is the whole reason the prefilter is here: a released lasso has a
+ * vertex for every few pixels the pointer travelled, so the unfiltered cost is
+ * the point count times a few hundred, per drag, on the frame the user is
+ * waiting for.
+ *
+ * Nothing is allocated per point. The rectangle is computed once, the answer
+ * is written into the mask, and the mask itself is reused when the caller
+ * hands one of the right size back.
+ * @param points - Where every point sits on screen.
+ * @param xs - Horizontal position of each vertex.
+ * @param ys - Vertical position of each vertex.
+ * @param vertexCount - How many leading entries are vertices. Their common length when omitted.
+ * @param into - A mask to write into, so a drag does not allocate one per frame. It is used only when it already has one entry per point; otherwise a new one is allocated, because silently answering about a different number of points is worse than the allocation.
+ * @returns One entry per point, `1` for inside and `0` for outside. All zeros for fewer than three vertices.
+ */
+export function pointsInPolygon(points, xs, ys, vertexCount, into) {
+    const pointsX = points.x;
+    const pointsY = points.y;
+    const total = Math.min(pointsX.length, pointsY.length);
+    const mask = into?.length === total ? into : new Uint8Array(total);
+    const count = usableVertexCount(xs, ys, vertexCount);
+    const bounds = count < 3 ? null : polygonBounds(xs, ys, count);
+    if (bounds === null) {
+        mask.fill(0);
+        return mask;
+    }
+    const { minX, minY, maxX, maxY } = bounds;
+    for (let index = 0; index < total; index++) {
+        const pointX = pointsX[index];
+        const pointY = pointsY[index];
+        if (pointX === undefined || pointY === undefined)
+            break;
+        if (pointX < minX || pointX > maxX || pointY < minY || pointY > maxY) {
+            mask[index] = 0;
+            continue;
+        }
+        mask[index] = pointInPolygon(pointX, pointY, xs, ys, count) ? 1 : 0;
+    }
+    return mask;
+}
+function usableVertexCount(xs, ys, vertexCount) {
+    const available = Math.min(xs.length, ys.length);
+    if (vertexCount === undefined)
+        return available;
+    if (!Number.isFinite(vertexCount))
+        return 0;
+    return Math.max(0, Math.min(available, Math.floor(vertexCount)));
+}
+//# sourceMappingURL=polygon.js.map

package/lib/scatter/core/polygon.js.map

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

package/lib/scatter/core/scatterSelection.d.ts

@@ -0,0 +1,44 @@
+/** How a fresh set of hits joins the selection that is already on screen. */
+export type ScatterSelectionMode = 'replace' | 'add' | 'remove';
+/**
+ * The selection a gesture leaves behind, from the one before it and its hits.
+ *
+ * The result is always as long as `base`, because that is the cloud's own
+ * length and the only length a selection is meaningful at. A `hits` mask that
+ * is short leaves the points past its end untouched — an honest reading of "no
+ * hit there" — rather than throwing at the end of a drag.
+ *
+ * Every entry written is `0` or `1`, so a mask that has been through this
+ * function can be compared with `toStrictEqual` and handed to a renderer that
+ * only checks for truthiness, whatever the caller filled its input with.
+ * @param base - The selection before the gesture, one entry per point.
+ * @param hits - The points the gesture caught, one entry per point; a non-zero entry is a hit.
+ * @param mode - Whether the hits stand alone, join the selection, or leave it.
+ * @param into - A mask to write into, so a drag does not allocate one per frame. It is used only when it already has one entry per point; otherwise a new one is allocated.
+ * @returns The new selection, one `0` or `1` per point.
+ */
+export declare function mergeScatterSelection(base: Uint8Array, hits: Uint8Array, mode: ScatterSelectionMode, into?: Uint8Array): Uint8Array;
+/**
+ * Which points a mask has selected, as their indices.
+ *
+ * The list is what a caller reports, serialises or hands to a table, so it is
+ * a plain array of numbers and not a third mask; it comes out ascending
+ * because the mask is read in order.
+ * @param mask - One entry per point; a non-zero entry is selected.
+ * @returns The selected indices, ascending.
+ */
+export declare function scatterSelectedIndices(mask: Uint8Array): number[];
+/**
+ * A mask over a cloud, from the indices that are selected.
+ *
+ * The inverse of {@link scatterSelectedIndices}, and the door a selection
+ * restored from a URL or a parent component comes in through. An index that is
+ * negative, past the end, or not a whole number is dropped rather than
+ * throwing: those lists arrive from outside, and a stale index in one is a
+ * reason to select one point fewer, not to fail a render.
+ * @param indices - The selected indices, in any order and possibly repeated.
+ * @param count - How many points the cloud holds.
+ * @returns One `0` or `1` per point.
+ */
+export declare function scatterSelectionMask(indices: Iterable<number>, count: number): Uint8Array;
+//# sourceMappingURL=scatterSelection.d.ts.map

package/lib/scatter/core/scatterSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scatterSelection.d.ts","sourceRoot":"","sources":["../../../src/scatter/core/scatterSelection.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,MAAM,MAAM,oBAAoB,GAAG,SAAS,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEhE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,oBAAoB,EAC1B,IAAI,CAAC,EAAE,UAAU,GAChB,UAAU,CAkBZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,CAOjE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,EACzB,KAAK,EAAE,MAAM,GACZ,UAAU,CASZ"}

package/lib/scatter/core/scatterSelection.js

@@ -0,0 +1,81 @@
+/**
+ * The selection a gesture leaves behind, from the one before it and its hits.
+ *
+ * The result is always as long as `base`, because that is the cloud's own
+ * length and the only length a selection is meaningful at. A `hits` mask that
+ * is short leaves the points past its end untouched — an honest reading of "no
+ * hit there" — rather than throwing at the end of a drag.
+ *
+ * Every entry written is `0` or `1`, so a mask that has been through this
+ * function can be compared with `toStrictEqual` and handed to a renderer that
+ * only checks for truthiness, whatever the caller filled its input with.
+ * @param base - The selection before the gesture, one entry per point.
+ * @param hits - The points the gesture caught, one entry per point; a non-zero entry is a hit.
+ * @param mode - Whether the hits stand alone, join the selection, or leave it.
+ * @param into - A mask to write into, so a drag does not allocate one per frame. It is used only when it already has one entry per point; otherwise a new one is allocated.
+ * @returns The new selection, one `0` or `1` per point.
+ */
+export function mergeScatterSelection(base, hits, mode, into) {
+    const total = base.length;
+    const merged = into?.length === total ? into : new Uint8Array(total);
+    const replacing = mode === 'replace';
+    const removing = mode === 'remove';
+    for (let index = 0; index < total; index++) {
+        const previous = base[index];
+        const hit = hits[index];
+        const wasSelected = previous !== undefined && previous !== 0;
+        const isHit = hit !== undefined && hit !== 0;
+        let selected;
+        if (replacing)
+            selected = isHit;
+        else if (removing)
+            selected = wasSelected && !isHit;
+        else
+            selected = wasSelected || isHit;
+        merged[index] = selected ? 1 : 0;
+    }
+    return merged;
+}
+/**
+ * Which points a mask has selected, as their indices.
+ *
+ * The list is what a caller reports, serialises or hands to a table, so it is
+ * a plain array of numbers and not a third mask; it comes out ascending
+ * because the mask is read in order.
+ * @param mask - One entry per point; a non-zero entry is selected.
+ * @returns The selected indices, ascending.
+ */
+export function scatterSelectedIndices(mask) {
+    const indices = [];
+    for (let index = 0; index < mask.length; index++) {
+        const flag = mask[index];
+        if (flag !== undefined && flag !== 0)
+            indices.push(index);
+    }
+    return indices;
+}
+/**
+ * A mask over a cloud, from the indices that are selected.
+ *
+ * The inverse of {@link scatterSelectedIndices}, and the door a selection
+ * restored from a URL or a parent component comes in through. An index that is
+ * negative, past the end, or not a whole number is dropped rather than
+ * throwing: those lists arrive from outside, and a stale index in one is a
+ * reason to select one point fewer, not to fail a render.
+ * @param indices - The selected indices, in any order and possibly repeated.
+ * @param count - How many points the cloud holds.
+ * @returns One `0` or `1` per point.
+ */
+export function scatterSelectionMask(indices, count) {
+    const total = Number.isFinite(count) ? Math.max(0, Math.floor(count)) : 0;
+    const mask = new Uint8Array(total);
+    for (const index of indices) {
+        if (!Number.isInteger(index))
+            continue;
+        if (index < 0 || index >= total)
+            continue;
+        mask[index] = 1;
+    }
+    return mask;
+}
+//# sourceMappingURL=scatterSelection.js.map

package/lib/scatter/core/scatterSelection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scatterSelection.js","sourceRoot":"","sources":["../../../src/scatter/core/scatterSelection.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,qBAAqB,CACnC,IAAgB,EAChB,IAAgB,EAChB,IAA0B,EAC1B,IAAiB;IAEjB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;IAC1B,MAAM,MAAM,GAAG,IAAI,EAAE,MAAM,KAAK,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC;IAErE,MAAM,SAAS,GAAG,IAAI,KAAK,SAAS,CAAC;IACrC,MAAM,QAAQ,GAAG,IAAI,KAAK,QAAQ,CAAC;IACnC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC;QAC3C,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;QAC7B,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;QACxB,MAAM,WAAW,GAAG,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,CAAC,CAAC;QAC7D,MAAM,KAAK,GAAG,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,CAAC,CAAC;QAC7C,IAAI,QAAiB,CAAC;QACtB,IAAI,SAAS;YAAE,QAAQ,GAAG,KAAK,CAAC;aAC3B,IAAI,QAAQ;YAAE,QAAQ,GAAG,WAAW,IAAI,CAAC,KAAK,CAAC;;YAC/C,QAAQ,GAAG,WAAW,IAAI,KAAK,CAAC;QACrC,MAAM,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACnC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,sBAAsB,CAAC,IAAgB;IACrD,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACjD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;QACzB,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,CAAC;YAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5D,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,oBAAoB,CAClC,OAAyB,EACzB,KAAa;IAEb,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1E,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC;IACnC,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC;YAAE,SAAS;QACvC,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI,KAAK;YAAE,SAAS;QAC1C,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAClB,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/lib/scatter/core/screenPoints.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Where every point sits on screen, as two parallel arrays.
+ *
+ * Parallel typed arrays rather than an array of objects: the hit tests are the
+ * only code that reads them, they read them in index order, and an `{ x, y }`
+ * per point would allocate one object per sample on every relayout.
+ */
+export interface ScreenPoints {
+    /** Horizontal position of each point, in pixels from the plot's left. */
+    x: Float64Array;
+    /** Vertical position of each point, in pixels from the plot's top. */
+    y: Float64Array;
+}
+/** The rectangle a set of coordinates spans, in pixels. */
+export interface PixelBounds {
+    /** Smallest horizontal position. */
+    minX: number;
+    /** Smallest vertical position. */
+    minY: number;
+    /** Largest horizontal position. */
+    maxX: number;
+    /** Largest vertical position. */
+    maxY: number;
+}
+/**
+ * The point nearest a position, when one is close enough to have been aimed at.
+ *
+ * Distances are compared squared. The caller only ever ranks them, so the
+ * square root would be computed once per point on every pointer move and then
+ * thrown away; a hover test over twenty thousand points is exactly where that
+ * is not affordable.
+ *
+ * A tie goes to the lower index. Two points that land on the same pixel then
+ * resolve the same way twice running, instead of the readout flickering
+ * between them as the pointer jitters.
+ * @param points - Where every point sits on screen.
+ * @param x - Horizontal position to search from, in pixels from the plot's left.
+ * @param y - Vertical position to search from, in pixels from the plot's top.
+ * @param radius - How far from that position to look, in pixels; a point exactly that far away still counts.
+ * @param included - One entry per point, a zero meaning the point cannot be hit. Every point can be hit when it is omitted, and a point past the end of a shorter mask cannot.
+ * @returns The index of the nearest point within the radius, or `-1` when no point is within it.
+ */
+export declare function nearestPointIndex(points: ScreenPoints, x: number, y: number, radius: number, included?: Uint8Array): number;
+/**
+ * Which points fall inside a rectangle.
+ *
+ * A zoomed plot draws only part of its cloud, and the dots left outside the
+ * frame are clipped rather than dropped: they are still in the coordinate
+ * arrays, still one pixel away from the frame's edge, and still the nearest
+ * point to a pointer resting just inside it. Without this mask a reader
+ * zoomed in on one crowd gets hover cards about samples they cannot see.
+ * @param points - Where every point sits on screen.
+ * @param bounds - The rectangle, normally the plot's own; a point on an edge is inside it.
+ * @param into - A mask to write into, so a resize does not allocate one per frame. It is used only when it already has one entry per point.
+ * @returns One entry per point, `1` for inside.
+ */
+export declare function pointsWithinBounds(points: ScreenPoints, bounds: PixelBounds, into?: Uint8Array): Uint8Array;
+//# sourceMappingURL=screenPoints.d.ts.map

package/lib/scatter/core/screenPoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screenPoints.d.ts","sourceRoot":"","sources":["../../../src/scatter/core/screenPoints.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,yEAAyE;IACzE,CAAC,EAAE,YAAY,CAAC;IAChB,sEAAsE;IACtE,CAAC,EAAE,YAAY,CAAC;CACjB;AAED,2DAA2D;AAC3D,MAAM,WAAW,WAAW;IAC1B,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,YAAY,EACpB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,UAAU,GACpB,MAAM,CA2BR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,WAAW,EACnB,IAAI,CAAC,EAAE,UAAU,GAChB,UAAU,CAaZ"}

package/lib/scatter/core/screenPoints.js

@@ -0,0 +1,78 @@
+/**
+ * The point nearest a position, when one is close enough to have been aimed at.
+ *
+ * Distances are compared squared. The caller only ever ranks them, so the
+ * square root would be computed once per point on every pointer move and then
+ * thrown away; a hover test over twenty thousand points is exactly where that
+ * is not affordable.
+ *
+ * A tie goes to the lower index. Two points that land on the same pixel then
+ * resolve the same way twice running, instead of the readout flickering
+ * between them as the pointer jitters.
+ * @param points - Where every point sits on screen.
+ * @param x - Horizontal position to search from, in pixels from the plot's left.
+ * @param y - Vertical position to search from, in pixels from the plot's top.
+ * @param radius - How far from that position to look, in pixels; a point exactly that far away still counts.
+ * @param included - One entry per point, a zero meaning the point cannot be hit. Every point can be hit when it is omitted, and a point past the end of a shorter mask cannot.
+ * @returns The index of the nearest point within the radius, or `-1` when no point is within it.
+ */
+export function nearestPointIndex(points, x, y, radius, included) {
+    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(radius)) {
+        return -1;
+    }
+    const xs = points.x;
+    const ys = points.y;
+    let count = Math.min(xs.length, ys.length);
+    if (included !== undefined)
+        count = Math.min(count, included.length);
+    const limit = radius * radius;
+    let nearest = -1;
+    let nearestDistance = 0;
+    for (let index = 0; index < count; index++) {
+        if (included?.[index] === 0)
+            continue;
+        const pointX = xs[index];
+        const pointY = ys[index];
+        if (pointX === undefined || pointY === undefined)
+            break;
+        const deltaX = pointX - x;
+        const deltaY = pointY - y;
+        const distance = deltaX * deltaX + deltaY * deltaY;
+        if (distance > limit)
+            continue;
+        if (nearest === -1 || distance < nearestDistance) {
+            nearest = index;
+            nearestDistance = distance;
+        }
+    }
+    return nearest;
+}
+/**
+ * Which points fall inside a rectangle.
+ *
+ * A zoomed plot draws only part of its cloud, and the dots left outside the
+ * frame are clipped rather than dropped: they are still in the coordinate
+ * arrays, still one pixel away from the frame's edge, and still the nearest
+ * point to a pointer resting just inside it. Without this mask a reader
+ * zoomed in on one crowd gets hover cards about samples they cannot see.
+ * @param points - Where every point sits on screen.
+ * @param bounds - The rectangle, normally the plot's own; a point on an edge is inside it.
+ * @param into - A mask to write into, so a resize does not allocate one per frame. It is used only when it already has one entry per point.
+ * @returns One entry per point, `1` for inside.
+ */
+export function pointsWithinBounds(points, bounds, into) {
+    const xs = points.x;
+    const ys = points.y;
+    const count = Math.min(xs.length, ys.length);
+    const mask = into?.length === count ? into.fill(0) : new Uint8Array(count);
+    const { minX, minY, maxX, maxY } = bounds;
+    for (let index = 0; index < count; index++) {
+        const x = xs[index] ?? Number.NaN;
+        const y = ys[index] ?? Number.NaN;
+        if (x < minX || x > maxX || y < minY || y > maxY)
+            continue;
+        mask[index] = 1;
+    }
+    return mask;
+}
+//# sourceMappingURL=screenPoints.js.map

package/lib/scatter/core/screenPoints.js.map

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

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

@@ -0,0 +1,69 @@
+import type { ReactElement } from 'react';
+import type { ChartScale } from '../../chart/core/chartScale.ts';
+import type { EllipseSize } from '../core/confidenceEllipse.ts';
+/** What {@link ScatterEllipseLayer} needs. */
+export interface ScatterEllipseLayerProps {
+    /** Horizontal coordinate of every point, in data units. */
+    x: ArrayLike<number>;
+    /** Vertical coordinate of every point, in the same order. */
+    y: ArrayLike<number>;
+    /**
+     * Which group each point belongs to, as an index into `colors`. A point with
+     * `-1`, or an index outside the range, is left out of every outline.
+     */
+    groupOf: ArrayLike<number>;
+    /** The colour of each group, in group order. */
+    colors: readonly string[];
+    /** Data to pixels, horizontally. */
+    scaleX: ChartScale;
+    /** Data to pixels, vertically; its `factor` is negative. */
+    scaleY: ChartScale;
+    /**
+     * How much of each group its outline holds.
+     * @default { kind: 'coverage', probability: 0.95 }
+     */
+    size?: EllipseSize;
+    /**
+     * How many points a group needs before it is outlined at all. Below it the
+     * shape says more about the sample than about the group.
+     * @default 3
+     */
+    minimumPoints?: number;
+    /**
+     * How strongly each outline is drawn, in group order.
+     * @default undefined — every outline is drawn at full strength
+     */
+    opacities?: readonly number[];
+    /**
+     * How solid each region is; `0` draws nothing at all, since the fill is the
+     * whole outline. Turn it down when many groups overlap, since the fills
+     * compound.
+     * @default SCATTER_OUTLINE_FILL_OPACITY
+     */
+    fillOpacity?: number;
+    /**
+     * Called with the groups too small to outline, as indices into `colors`,
+     * whenever that set changes. An outline that quietly fails to appear reads
+     * as a bug in the plot, so the caller is handed what its caption has to
+     * account for.
+     * @default undefined
+     */
+    onSkippedGroups?: (groups: readonly number[]) => void;
+}
+/**
+ * One outline per group, drawn through both scales.
+ *
+ * The outline is measured in the data's own units and drawn in pixels, and the
+ * two axes almost never carry the same number of units per pixel — so scaling
+ * the two radii and keeping the data-space angle would draw an ellipse of the
+ * wrong shape at the wrong tilt. `scatterOutlineShape` transforms the spread
+ * first and decomposes it after, which is exact on a linear axis.
+ *
+ * The outlines are drawn under the dots, which is what lets the region be
+ * filled at all: the fill says where a group sits without taking the dots the
+ * reader is there to count.
+ * @param props - See {@link ScatterEllipseLayerProps}.
+ * @returns The outlines.
+ */
+export declare const ScatterEllipseLayer: import("react").MemoExoticComponent<(props: ScatterEllipseLayerProps) => ReactElement>;
+//# sourceMappingURL=ScatterEllipseLayer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScatterEllipseLayer.d.ts","sourceRoot":"","sources":["../../../src/scatter/ui/ScatterEllipseLayer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAG1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,KAAK,EAAgB,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAK9E,8CAA8C;AAC9C,MAAM,WAAW,wBAAwB;IACvC,2DAA2D;IAC3D,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IACrB,6DAA6D;IAC7D,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IACrB;;;OAGG;IACH,OAAO,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAC3B,gDAAgD;IAChD,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,oCAAoC;IACpC,MAAM,EAAE,UAAU,CAAC;IACnB,4DAA4D;IAC5D,MAAM,EAAE,UAAU,CAAC;IACnB;;;OAGG;IACH,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,KAAK,IAAI,CAAC;CACvD;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,8CACvB,wBAAwB,KAC9B,YAAY,CAiCb,CAAC"}

package/lib/scatter/ui/ScatterEllipseLayer.js

@@ -0,0 +1,77 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo, useEffect, useRef } from 'react';
+import { confidenceEllipse } from "../core/confidenceEllipse.js";
+import { scatterOutlineShape } from "./scatterOutlineShape.js";
+/**
+ * One outline per group, drawn through both scales.
+ *
+ * The outline is measured in the data's own units and drawn in pixels, and the
+ * two axes almost never carry the same number of units per pixel — so scaling
+ * the two radii and keeping the data-space angle would draw an ellipse of the
+ * wrong shape at the wrong tilt. `scatterOutlineShape` transforms the spread
+ * first and decomposes it after, which is exact on a linear axis.
+ *
+ * The outlines are drawn under the dots, which is what lets the region be
+ * filled at all: the fill says where a group sits without taking the dots the
+ * reader is there to count.
+ * @param props - See {@link ScatterEllipseLayerProps}.
+ * @returns The outlines.
+ */
+export const ScatterEllipseLayer = memo(function ScatterEllipseLayer(props) {
+    const { x, y, groupOf, colors, scaleX, scaleY, size = DEFAULT_SIZE, minimumPoints = 3, opacities, fillOpacity, onSkippedGroups, } = props;
+    const clouds = groupClouds(x, y, groupOf, colors.length);
+    const outlines = [];
+    const skipped = [];
+    for (let group = 0; group < clouds.length; group++) {
+        const color = colors[group];
+        const cloud = clouds[group];
+        if (color === undefined || cloud === undefined)
+            continue;
+        const measured = confidenceEllipse(cloud, { size, minimumPoints });
+        if (measured === null) {
+            skipped.push(group);
+            continue;
+        }
+        const ink = { color, opacity: opacities?.[group], fillOpacity };
+        outlines.push(scatterOutlineShape(group, measured, scaleX, scaleY, ink));
+    }
+    useSkippedReport(skipped, onSkippedGroups);
+    return _jsx("g", { "data-layer": "ellipses", children: outlines });
+});
+/** What a group is outlined at when the caller says nothing. */
+const DEFAULT_SIZE = { kind: 'coverage', probability: 0.95 };
+/* Each group's points, gathered once so every group is measured in one pass. */
+function groupClouds(x, y, groupOf, groups) {
+    const clouds = new Array(groups);
+    for (let group = 0; group < groups; group++)
+        clouds[group] = [];
+    const total = Math.min(x.length, y.length, groupOf.length);
+    for (let index = 0; index < total; index++) {
+        const group = groupOf[index];
+        if (group === undefined || group < 0 || group >= groups)
+            continue;
+        const px = x[index];
+        const py = y[index];
+        if (px === undefined || py === undefined)
+            continue;
+        clouds[group]?.push({ x: px, y: py });
+    }
+    return clouds;
+}
+/*
+ * Report the skipped groups once each time the set changes. A fresh array is
+ * built every render, so it is the joined indices that are compared and not
+ * the array, which is what keeps a caller storing the answer from re-rendering
+ * for ever.
+ */
+function useSkippedReport(skipped, report) {
+    const last = useRef('');
+    const key = skipped.join(' ');
+    useEffect(() => {
+        if (last.current === key)
+            return;
+        last.current = key;
+        report?.(skipped);
+    });
+}
+//# sourceMappingURL=ScatterEllipseLayer.js.map