react-cheminfo 0.9.0 → 0.11.0

package/lib/scatter/core/lassoPath.js

@@ -0,0 +1,101 @@
+const DEFAULT_CAPACITY = 256;
+/**
+ * An empty path, with room to grow.
+ * @param capacity - How many vertices to make room for before the first growth; at least one, and rounded down. Defaults to 256, which is a couple of seconds of dragging.
+ * @returns The path, holding no vertex yet.
+ */
+export function createLassoPath(capacity = DEFAULT_CAPACITY) {
+    const size = Number.isFinite(capacity)
+        ? Math.max(1, Math.floor(capacity))
+        : DEFAULT_CAPACITY;
+    return { xs: new Float64Array(size), ys: new Float64Array(size), length: 0 };
+}
+/**
+ * Empty a path without giving up the room it has claimed.
+ *
+ * The buffers are kept, so the second lasso of a session and the fiftieth cost
+ * nothing to start. Whatever is left past `length` is never read.
+ * @param path - The path to empty.
+ */
+export function resetLassoPath(path) {
+    path.length = 0;
+}
+/**
+ * Add a vertex, unless it is too near the last one kept.
+ *
+ * The distance is measured from the last vertex that was kept, not from the
+ * last position the pointer reported, so consecutive vertices are always at
+ * least `minDistance` apart however slowly the pointer is moving. Measuring
+ * from the raw sample instead would let a slow drag across the whole plot keep
+ * a single vertex, and the outline would close as a straight line between
+ * where the drag started and where it ended.
+ * @param path - The path to add to; its buffers are doubled when full.
+ * @param x - Horizontal position of the vertex, in pixels.
+ * @param y - Vertical position of the vertex, in pixels.
+ * @param minDistance - How far the pointer has to have moved for the vertex to be worth keeping, in pixels. Nothing is dropped when it is zero, negative, or not finite.
+ * @returns Whether the vertex was kept. A position that is not finite never is.
+ */
+export function appendLassoPoint(path, x, y, minDistance) {
+    if (!Number.isFinite(x) || !Number.isFinite(y))
+        return false;
+    if (path.length > 0) {
+        const lastX = path.xs[path.length - 1];
+        const lastY = path.ys[path.length - 1];
+        if (lastX !== undefined && lastY !== undefined) {
+            const gate = Number.isFinite(minDistance) && minDistance > 0
+                ? minDistance * minDistance
+                : 0;
+            const deltaX = x - lastX;
+            const deltaY = y - lastY;
+            if (deltaX * deltaX + deltaY * deltaY < gate)
+                return false;
+        }
+    }
+    if (path.length >= path.xs.length || path.length >= path.ys.length) {
+        growLassoPath(path);
+    }
+    path.xs[path.length] = x;
+    path.ys[path.length] = y;
+    path.length += 1;
+    return true;
+}
+/**
+ * The path as an SVG `d` attribute.
+ *
+ * Coordinates are rounded to a tenth of a pixel. A lasso is drawn at a
+ * resolution the eye cannot resolve past that, and the full doubles would put
+ * seventeen characters per vertex into an attribute that is rewritten on every
+ * frame of the drag.
+ * @param path - The path to write out.
+ * @param close - Whether to close the ring with a `Z`, which is what turns the drawn line into the shape that is about to be tested.
+ * @returns The `d` attribute, or an empty string when the path holds no vertex.
+ */
+export function lassoPathData(path, close) {
+    const count = Math.min(path.length, path.xs.length, path.ys.length);
+    let data = '';
+    for (let index = 0; index < count; index++) {
+        const x = path.xs[index];
+        const y = path.ys[index];
+        if (x === undefined || y === undefined)
+            break;
+        data += `${index === 0 ? 'M' : ' L'}${roundToTenth(x)},${roundToTenth(y)}`;
+    }
+    if (data.length === 0)
+        return '';
+    return close ? `${data}Z` : data;
+}
+function growLassoPath(path) {
+    const capacity = Math.max(1, Math.min(path.xs.length, path.ys.length)) * 2;
+    const xs = new Float64Array(capacity);
+    const ys = new Float64Array(capacity);
+    xs.set(path.xs);
+    ys.set(path.ys);
+    path.xs = xs;
+    path.ys = ys;
+}
+function roundToTenth(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.round(value * 10) / 10;
+}
+//# sourceMappingURL=lassoPath.js.map

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

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

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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"}