react-cheminfo 0.69.0 → 0.71.0

package/lib/mass/core/nearestPeak.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Which peak the pointer is asking about.
+ *
+ * One question, asked by the crosshair, by the click that frames a peak and by
+ * the hover that lights a row of the peak table — so it is answered once, here,
+ * and all three agree about what is under the pointer.
+ */
+import type { ChartScale } from '../../chart/core/chartScale.ts';
+import type { MassSpectrum } from './massSpectrum.ts';
+/**
+ * How far from a stick the pointer may be and still be on it, in screen pixels.
+ *
+ * A screen distance, not a mass one: it is the size of a pointing gesture and
+ * has nothing to say about how close two m/z values are. Six pixels is about the
+ * jitter of a hand resting on a trackpad, and narrow enough that two sticks a
+ * few tenths apart on a zoomed axis stay separately reachable.
+ */
+export declare const PEAK_HIT_RADIUS = 6;
+/** The peak under the pointer, and which spectrum it belongs to. */
+export interface NearestPeak {
+    /** The spectrum whose centroid holds it. */
+    spectrumId: string;
+    /** Where it sits in that centroid, for looking its charge up. */
+    index: number;
+    /** Its m/z, exactly as the centroid records it. */
+    mz: number;
+    /** Its intensity. */
+    intensity: number;
+}
+/**
+ * The peak the pointer is on, tested on m/z alone.
+ *
+ * Only the horizontal distance is measured, so the whole column above a stick is
+ * within reach up to the top of the plot. Matching in two dimensions instead
+ * sounds more precise and is unusable: the target for a peak at one percent of
+ * the base peak would be the few pixels around its tip, so the smallest peaks —
+ * the ones worth interrogating — become the hardest to reach.
+ * @param spectra - What the chart draws; those with neither trace drawn are
+ * skipped. A spectrum drawn as its profile answers with its picked peaks all the
+ * same — they are what the pointer is really asking after.
+ * @param xScale - The m/z axis as it is currently zoomed.
+ * @param pixelX - Where the pointer is, in the same pixels the scale speaks.
+ * @param maxDistance - How far away a stick may be, in pixels; a stick exactly
+ * that far away misses. Defaults to `PEAK_HIT_RADIUS`.
+ * @returns The closest peak within that distance, `null` when there is none.
+ */
+export declare function nearestPeakMz(spectra: readonly MassSpectrum[], xScale: ChartScale, pixelX: number, maxDistance?: number): NearestPeak | null;
+/**
+ * The peak a gesture landed on, given where it landed in m/z.
+ *
+ * A gesture is reported in the units the chart is measured in, while how near a
+ * stick has to be to be the one meant is a distance on the screen — so the mass
+ * goes back through the scale rather than the radius being turned into a mass,
+ * which would be a different tolerance at every zoom.
+ * @param spectra - What the chart draws.
+ * @param xScale - The m/z axis as it is currently zoomed.
+ * @param mz - Where the gesture landed, in m/z.
+ * @param maxDistance - How far away a stick may be, in pixels. Defaults to
+ * `PEAK_HIT_RADIUS`.
+ * @returns The closest peak within that distance, `null` when there is none.
+ */
+export declare function peakAtMz(spectra: readonly MassSpectrum[], xScale: ChartScale, mz: number, maxDistance?: number): NearestPeak | null;
+/**
+ * Whether two answers about the peak under the pointer say the same thing.
+ *
+ * The m/z is compared exactly, and that is not an oversight: both numbers were
+ * read out of the same centroid by the same index, so either they are the very
+ * same measurement or they are two different peaks. A tolerance here would
+ * declare an isotopologue pair a millimass unit apart to be one peak.
+ * @param current - What was last reported.
+ * @param next - What would be reported now.
+ * @returns Whether the report can be skipped.
+ */
+export declare function sameNearestPeak(current: NearestPeak | null, next: NearestPeak | null): boolean;
+//# sourceMappingURL=nearestPeak.d.ts.map

package/lib/mass/core/nearestPeak.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nearestPeak.d.ts","sourceRoot":"","sources":["../../../src/mass/core/nearestPeak.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAGjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGtD;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,IAAI,CAAC;AAEjC,oEAAoE;AACpE,MAAM,WAAW,WAAW;IAC1B,4CAA4C;IAC5C,UAAU,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,EAAE,EAAE,MAAM,CAAC;IACX,qBAAqB;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,WAAW,SAAkB,GAC5B,WAAW,GAAG,IAAI,CAsBpB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,MAAM,EAAE,UAAU,EAClB,EAAE,EAAE,MAAM,EACV,WAAW,SAAkB,GAC5B,WAAW,GAAG,IAAI,CAEpB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,GAAG,IAAI,EAC3B,IAAI,EAAE,WAAW,GAAG,IAAI,GACvB,OAAO,CAQT"}

package/lib/mass/core/nearestPeak.js

@@ -0,0 +1,99 @@
+/**
+ * Which peak the pointer is asking about.
+ *
+ * One question, asked by the crosshair, by the click that frames a peak and by
+ * the hover that lights a row of the peak table — so it is answered once, here,
+ * and all three agree about what is under the pointer.
+ */
+import { xFindClosestIndex } from 'ml-spectra-processing';
+import { chartPixel, chartValue } from "../../chart/core/chartScale.js";
+import { isSpectrumDrawn } from "./massSpectrum.js";
+/**
+ * How far from a stick the pointer may be and still be on it, in screen pixels.
+ *
+ * A screen distance, not a mass one: it is the size of a pointing gesture and
+ * has nothing to say about how close two m/z values are. Six pixels is about the
+ * jitter of a hand resting on a trackpad, and narrow enough that two sticks a
+ * few tenths apart on a zoomed axis stay separately reachable.
+ */
+export const PEAK_HIT_RADIUS = 6;
+/**
+ * The peak the pointer is on, tested on m/z alone.
+ *
+ * Only the horizontal distance is measured, so the whole column above a stick is
+ * within reach up to the top of the plot. Matching in two dimensions instead
+ * sounds more precise and is unusable: the target for a peak at one percent of
+ * the base peak would be the few pixels around its tip, so the smallest peaks —
+ * the ones worth interrogating — become the hardest to reach.
+ * @param spectra - What the chart draws; those with neither trace drawn are
+ * skipped. A spectrum drawn as its profile answers with its picked peaks all the
+ * same — they are what the pointer is really asking after.
+ * @param xScale - The m/z axis as it is currently zoomed.
+ * @param pixelX - Where the pointer is, in the same pixels the scale speaks.
+ * @param maxDistance - How far away a stick may be, in pixels; a stick exactly
+ * that far away misses. Defaults to `PEAK_HIT_RADIUS`.
+ * @returns The closest peak within that distance, `null` when there is none.
+ */
+export function nearestPeakMz(spectra, xScale, pixelX, maxDistance = PEAK_HIT_RADIUS) {
+    const target = chartValue(xScale, pixelX);
+    let best = null;
+    let bestDistance = maxDistance;
+    for (const spectrum of spectra) {
+        if (!isSpectrumDrawn(spectrum))
+            continue;
+        const { x, y } = spectrum.centroid;
+        if (x.length === 0)
+            continue;
+        const index = xFindClosestIndex(x, target);
+        const mz = x[index];
+        const distance = Math.abs(chartPixel(xScale, mz) - pixelX);
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            best = {
+                spectrumId: spectrum.id,
+                index,
+                mz,
+                intensity: y[index],
+            };
+        }
+    }
+    return best;
+}
+/**
+ * The peak a gesture landed on, given where it landed in m/z.
+ *
+ * A gesture is reported in the units the chart is measured in, while how near a
+ * stick has to be to be the one meant is a distance on the screen — so the mass
+ * goes back through the scale rather than the radius being turned into a mass,
+ * which would be a different tolerance at every zoom.
+ * @param spectra - What the chart draws.
+ * @param xScale - The m/z axis as it is currently zoomed.
+ * @param mz - Where the gesture landed, in m/z.
+ * @param maxDistance - How far away a stick may be, in pixels. Defaults to
+ * `PEAK_HIT_RADIUS`.
+ * @returns The closest peak within that distance, `null` when there is none.
+ */
+export function peakAtMz(spectra, xScale, mz, maxDistance = PEAK_HIT_RADIUS) {
+    return nearestPeakMz(spectra, xScale, chartPixel(xScale, mz), maxDistance);
+}
+/**
+ * Whether two answers about the peak under the pointer say the same thing.
+ *
+ * The m/z is compared exactly, and that is not an oversight: both numbers were
+ * read out of the same centroid by the same index, so either they are the very
+ * same measurement or they are two different peaks. A tolerance here would
+ * declare an isotopologue pair a millimass unit apart to be one peak.
+ * @param current - What was last reported.
+ * @param next - What would be reported now.
+ * @returns Whether the report can be skipped.
+ */
+export function sameNearestPeak(current, next) {
+    if (current === next)
+        return true;
+    if (current === null || next === null)
+        return false;
+    return (current.spectrumId === next.spectrumId &&
+        current.index === next.index &&
+        current.mz === next.mz);
+}
+//# sourceMappingURL=nearestPeak.js.map

package/lib/mass/core/nearestPeak.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nearestPeak.js","sourceRoot":"","sources":["../../../src/mass/core/nearestPeak.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAG1D,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAGxE,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC;AAcjC;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,aAAa,CAC3B,OAAgC,EAChC,MAAkB,EAClB,MAAc,EACd,WAAW,GAAG,eAAe;IAE7B,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,IAAI,IAAI,GAAuB,IAAI,CAAC;IACpC,IAAI,YAAY,GAAG,WAAW,CAAC;IAC/B,KAAK,MAAM,QAAQ,IAAI,OAAO,EAAE,CAAC;QAC/B,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC;YAAE,SAAS;QACzC,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,QAAQ,CAAC,QAAQ,CAAC;QACnC,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC;YAAE,SAAS;QAC7B,MAAM,KAAK,GAAG,iBAAiB,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;QAC3C,MAAM,EAAE,GAAG,CAAC,CAAC,KAAK,CAAW,CAAC;QAC9B,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC;QAC3D,IAAI,QAAQ,GAAG,YAAY,EAAE,CAAC;YAC5B,YAAY,GAAG,QAAQ,CAAC;YACxB,IAAI,GAAG;gBACL,UAAU,EAAE,QAAQ,CAAC,EAAE;gBACvB,KAAK;gBACL,EAAE;gBACF,SAAS,EAAE,CAAC,CAAC,KAAK,CAAW;aAC9B,CAAC;QACJ,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,QAAQ,CACtB,OAAgC,EAChC,MAAkB,EAClB,EAAU,EACV,WAAW,GAAG,eAAe;IAE7B,OAAO,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,WAAW,CAAC,CAAC;AAC7E,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,eAAe,CAC7B,OAA2B,EAC3B,IAAwB;IAExB,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAClC,IAAI,OAAO,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IACpD,OAAO,CACL,OAAO,CAAC,UAAU,KAAK,IAAI,CAAC,UAAU;QACtC,OAAO,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK;QAC5B,OAAO,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CACvB,CAAC;AACJ,CAAC"}

package/lib/mass/core/peakLabelLines.d.ts

@@ -0,0 +1,77 @@
+/**
+ * What the stack of labels above a peak says.
+ *
+ * A label is never one line: a peak carries its m/z and its intensity always,
+ * its charge when one was established, and the name of whatever explains it
+ * when a host says something does. Which of those are present changes from peak
+ * to peak, so the stack is built as a list and measured from its length — **an
+ * absent line consumes no slot**, and a peak nothing explains is not drawn with
+ * a gap where its name would have been.
+ *
+ * The lines come back farthest-from-the-peak first, which for a stack standing
+ * over a stick is also top-to-bottom reading order. Where those lines are then
+ * written is `labelStackBaselines` in the shared chart, which is the same sum
+ * for every kind of spectrum.
+ */
+import type { MassPeakObject } from './centroidPeaks.ts';
+/** What one line of a stack is about. */
+export type PeakLabelLineKind = 'annotation' | 'charge' | 'mz' | 'intensity';
+/** One line of the stack above a peak. */
+export interface PeakLabelLine {
+    /** What it is about, which is also its key within the stack. */
+    kind: PeakLabelLineKind;
+    /** What it says. */
+    text: string;
+}
+/** What a stack is allowed to say about one peak. */
+export interface PeakLabelLinesOptions {
+    /**
+     * How many decimals the masses on screen are written with, as `mzDecimalsOf`
+     * decides, so a nominal-mass table is not written out to four decimals it
+     * never measured.
+     * @default 4
+     */
+    mzDecimals?: number;
+    /**
+     * Whether a peak whose charge was established says so. A charge of `0` means
+     * none was established and is never written, whatever this says.
+     * @default false
+     */
+    showCharges?: boolean;
+    /**
+     * The name of whatever explains this peak, absent when nothing does.
+     * @default undefined
+     */
+    annotationLabel?: string;
+    /**
+     * What one unit of the measured intensity is written as.
+     *
+     * One for every spectrum on the 0–100 scale; a spectrum that kept the counts
+     * its instrument recorded — a pixel of an imaging run — is written through a
+     * factor its host settles for the whole chart, so the numbers over the peaks
+     * and the numbers up the axis cannot disagree.
+     * @default 1
+     */
+    intensityScale?: number;
+}
+/**
+ * The lines the stack above one peak is made of.
+ *
+ * Ordered by how much of an answer each line is, the answer farthest from the
+ * stick and the measurement nearest it: the name of whatever explains the peak,
+ * then the charge, which qualifies the mass below it, then the m/z, which is
+ * what a chemist came to read, and the intensity last, sitting on the stick
+ * whose height already said it.
+ * @param peak - The peak being labelled.
+ * @param options - What the stack is allowed to say.
+ * @returns The lines, farthest from the peak first, never empty.
+ */
+export declare function peakLabelLines(peak: MassPeakObject, options?: PeakLabelLinesOptions): PeakLabelLine[];
+/**
+ * How one peak of one spectrum is keyed, wherever something is said about it.
+ * @param spectrumId - Identity of the spectrum.
+ * @param index - Where the peak sits in that spectrum's centroid.
+ * @returns `${spectrumId}:${index}`.
+ */
+export declare function peakKey(spectrumId: string, index: number): string;
+//# sourceMappingURL=peakLabelLines.d.ts.map

package/lib/mass/core/peakLabelLines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peakLabelLines.d.ts","sourceRoot":"","sources":["../../../src/mass/core/peakLabelLines.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAIzD,yCAAyC;AACzC,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG,QAAQ,GAAG,IAAI,GAAG,WAAW,CAAC;AAE7E,0CAA0C;AAC1C,MAAM,WAAW,aAAa;IAC5B,gEAAgE;IAChE,IAAI,EAAE,iBAAiB,CAAC;IACxB,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,qDAAqD;AACrD,MAAM,WAAW,qBAAqB;IACpC;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,cAAc,EACpB,OAAO,GAAE,qBAA0B,GAClC,aAAa,EAAE,CAuBjB;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEjE"}

package/lib/mass/core/peakLabelLines.js

@@ -0,0 +1,54 @@
+/**
+ * What the stack of labels above a peak says.
+ *
+ * A label is never one line: a peak carries its m/z and its intensity always,
+ * its charge when one was established, and the name of whatever explains it
+ * when a host says something does. Which of those are present changes from peak
+ * to peak, so the stack is built as a list and measured from its length — **an
+ * absent line consumes no slot**, and a peak nothing explains is not drawn with
+ * a gap where its name would have been.
+ *
+ * The lines come back farthest-from-the-peak first, which for a stack standing
+ * over a stick is also top-to-bottom reading order. Where those lines are then
+ * written is `labelStackBaselines` in the shared chart, which is the same sum
+ * for every kind of spectrum.
+ */
+import { formatIntensity, formatMz } from "./massFormat.js";
+import { MZ_DECIMALS } from "./massResolution.js";
+/**
+ * The lines the stack above one peak is made of.
+ *
+ * Ordered by how much of an answer each line is, the answer farthest from the
+ * stick and the measurement nearest it: the name of whatever explains the peak,
+ * then the charge, which qualifies the mass below it, then the m/z, which is
+ * what a chemist came to read, and the intensity last, sitting on the stick
+ * whose height already said it.
+ * @param peak - The peak being labelled.
+ * @param options - What the stack is allowed to say.
+ * @returns The lines, farthest from the peak first, never empty.
+ */
+export function peakLabelLines(peak, options = {}) {
+    const { mzDecimals = MZ_DECIMALS.high, showCharges = false, annotationLabel, intensityScale = 1, } = options;
+    const lines = [];
+    if (annotationLabel !== undefined && annotationLabel !== '') {
+        lines.push({ kind: 'annotation', text: annotationLabel });
+    }
+    if (showCharges && peak.charge !== 0) {
+        lines.push({ kind: 'charge', text: `z = ${peak.charge}` });
+    }
+    lines.push({ kind: 'mz', text: formatMz(peak.x, mzDecimals) }, {
+        kind: 'intensity',
+        text: formatIntensity(peak.y * intensityScale, mzDecimals),
+    });
+    return lines;
+}
+/**
+ * How one peak of one spectrum is keyed, wherever something is said about it.
+ * @param spectrumId - Identity of the spectrum.
+ * @param index - Where the peak sits in that spectrum's centroid.
+ * @returns `${spectrumId}:${index}`.
+ */
+export function peakKey(spectrumId, index) {
+    return `${spectrumId}:${index}`;
+}
+//# sourceMappingURL=peakLabelLines.js.map

package/lib/mass/core/peakLabelLines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"peakLabelLines.js","sourceRoot":"","sources":["../../../src/mass/core/peakLabelLines.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AA6ClD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,cAAc,CAC5B,IAAoB,EACpB,UAAiC,EAAE;IAEnC,MAAM,EACJ,UAAU,GAAG,WAAW,CAAC,IAAI,EAC7B,WAAW,GAAG,KAAK,EACnB,eAAe,EACf,cAAc,GAAG,CAAC,GACnB,GAAG,OAAO,CAAC;IAEZ,MAAM,KAAK,GAAoB,EAAE,CAAC;IAClC,IAAI,eAAe,KAAK,SAAS,IAAI,eAAe,KAAK,EAAE,EAAE,CAAC;QAC5D,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC;IAC5D,CAAC;IACD,IAAI,WAAW,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACrC,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAC7D,CAAC;IACD,KAAK,CAAC,IAAI,CACR,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,UAAU,CAAC,EAAE,EAClD;QACE,IAAI,EAAE,WAAW;QACjB,IAAI,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC,GAAG,cAAc,EAAE,UAAU,CAAC;KAC3D,CACF,CAAC;IACF,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CAAC,UAAkB,EAAE,KAAa;IACvD,OAAO,GAAG,UAAU,IAAI,KAAK,EAAE,CAAC;AAClC,CAAC"}

package/lib/mass/core/peakLabelPlan.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Where every labelled peak's numbers go, worked out before anything is drawn.
+ *
+ * Which peaks are labelled is `selectLabelledPeaks`, and the slots it makes that
+ * choice with are cut from the *window*: ten of them, whatever the chart is. A
+ * label is not — it is a number set at a fixed size, and `527.1607` is fifty
+ * pixels wide on a plot of any width. So a chart narrow enough for its slots to
+ * be thinner than that hands back two peaks whose stacks are written one across
+ * the other, and the two masses that result are neither.
+ *
+ * What settles it: **the taller peak keeps the room, and the fainter one goes
+ * without**. Never a nudge sideways — on a chart, distance from a stick is the
+ * only thing saying which stick a number belongs to, and a mass slid clear of
+ * its neighbour is a mass now hanging over somebody else's peak. The peak that
+ * loses its numbers keeps the mark on its tip, so it is not read as a peak the
+ * spectrum lacks, and a zoom widens the room and brings its stack straight back.
+ *
+ * Kept out of the component so that which peak was labelled, and at what pixel,
+ * is worth a test that no browser has to stand by for.
+ */
+import type { PlotRect } from '../../chart/core/chartGeometry.ts';
+import type { ChartScale } from '../../chart/core/chartScale.ts';
+import type { StackBox } from './labelStackBox.ts';
+import type { LabelledPeak } from './labelledPeaks.ts';
+import type { MassSpectrum } from './massSpectrum.ts';
+import type { PeakLabelLine } from './peakLabelLines.ts';
+/** The clear space kept between two stacks standing side by side. */
+export declare const LABEL_SPACING = 4;
+/** One labelled peak: its stick, its numbers, and where both are drawn. */
+export interface PeakLabelPlan {
+    /** The peak being labelled. */
+    peak: LabelledPeak;
+    /** `${spectrumId}:${index}`, which is how anything said about it is found. */
+    key: string;
+    /** Where its stick stands, in pixels across the SVG. */
+    tipX: number;
+    /** Where the tip of that stick is, in pixels down the SVG. */
+    tipY: number;
+    /**
+     * Where the stack is centred, which is over the tip unless the peak stands so
+     * near the edge of the plot that its numbers would be written half outside it.
+     * `NaN` for a peak crowded out of its numbers by a taller neighbour, which is
+     * still marked — it simply is not written.
+     */
+    labelX: number;
+    /** What the stack says, farthest line from the peak first. */
+    lines: PeakLabelLine[];
+    /** Where each of those lines is written, in the order the lines are in. */
+    baselines: Float64Array;
+    /** The room the stack takes, which is what answers the pointer. */
+    box: StackBox;
+}
+/** What a set of stacks is planned against. */
+export interface PlanPeakLabelsOptions {
+    /** The spectrum whose peaks are labelled, as it is drawn. */
+    spectrum: MassSpectrum;
+    /** Where the plot sits, which is what a stack may not be written outside of. */
+    plot: PlotRect;
+    /** The m/z axis as it is currently zoomed. */
+    xScale: ChartScale;
+    /** The intensity axis as it is currently zoomed. */
+    yScale: ChartScale;
+    /**
+     * How many peaks are labelled at most, the most intense first.
+     * @default the selection's own default
+     */
+    limit?: number;
+    /**
+     * Whether a peak whose charge was established says so.
+     * @default false
+     */
+    showCharges?: boolean;
+    /**
+     * How many decimals the masses on screen are written with.
+     * @default 4
+     */
+    mzDecimals?: number;
+    /**
+     * What explains each peak, keyed as `peakKey` keys it.
+     * @default undefined
+     */
+    annotationLabels?: ReadonlyMap<string, string>;
+    /**
+     * Whether the stacks hang under the sticks rather than standing over them,
+     * which is what the lower half of a mirrored pair wants.
+     * @default false
+     */
+    below?: boolean;
+    /**
+     * What one unit of the measured intensity is written as.
+     * @default 1
+     */
+    intensityScale?: number;
+}
+/**
+ * Plan the stacks for the window on screen.
+ *
+ * The crowding is settled before a single line is composed, and settled in
+ * descending intensity: the tallest peak of the window asks for its stretch of
+ * the axis first and keeps it, and every fainter peak standing closer than a
+ * label is wide loses its `labelX`. What comes back is in ascending m/z, so the
+ * drawing order is the axis order and a stack keeps its key from one render to
+ * the next.
+ * @param options - The spectrum, the axes, and what the stacks may say.
+ * @returns One plan per peak that earned a label, in ascending m/z, those
+ * crowded out among them.
+ */
+export declare function planPeakLabels(options: PlanPeakLabelsOptions): PeakLabelPlan[];
+//# sourceMappingURL=peakLabelPlan.d.ts.map

package/lib/mass/core/peakLabelPlan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peakLabelPlan.d.ts","sourceRoot":"","sources":["../../../src/mass/core/peakLabelPlan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAKjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzD,qEAAqE;AACrE,eAAO,MAAM,aAAa,IAAI,CAAC;AAE/B,2EAA2E;AAC3E,MAAM,WAAW,aAAa;IAC5B,+BAA+B;IAC/B,IAAI,EAAE,YAAY,CAAC;IACnB,8EAA8E;IAC9E,GAAG,EAAE,MAAM,CAAC;IACZ,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,8DAA8D;IAC9D,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,2EAA2E;IAC3E,SAAS,EAAE,YAAY,CAAC;IACxB,mEAAmE;IACnE,GAAG,EAAE,QAAQ,CAAC;CACf;AAED,+CAA+C;AAC/C,MAAM,WAAW,qBAAqB;IACpC,6DAA6D;IAC7D,QAAQ,EAAE,YAAY,CAAC;IACvB,gFAAgF;IAChF,IAAI,EAAE,QAAQ,CAAC;IACf,8CAA8C;IAC9C,MAAM,EAAE,UAAU,CAAC;IACnB,oDAAoD;IACpD,MAAM,EAAE,UAAU,CAAC;IACnB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/C;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,qBAAqB,GAC7B,aAAa,EAAE,CAsDjB"}

package/lib/mass/core/peakLabelPlan.js

@@ -0,0 +1,143 @@
+/**
+ * Where every labelled peak's numbers go, worked out before anything is drawn.
+ *
+ * Which peaks are labelled is `selectLabelledPeaks`, and the slots it makes that
+ * choice with are cut from the *window*: ten of them, whatever the chart is. A
+ * label is not — it is a number set at a fixed size, and `527.1607` is fifty
+ * pixels wide on a plot of any width. So a chart narrow enough for its slots to
+ * be thinner than that hands back two peaks whose stacks are written one across
+ * the other, and the two masses that result are neither.
+ *
+ * What settles it: **the taller peak keeps the room, and the fainter one goes
+ * without**. Never a nudge sideways — on a chart, distance from a stick is the
+ * only thing saying which stick a number belongs to, and a mass slid clear of
+ * its neighbour is a mass now hanging over somebody else's peak. The peak that
+ * loses its numbers keeps the mark on its tip, so it is not read as a peak the
+ * spectrum lacks, and a zoom widens the room and brings its stack straight back.
+ *
+ * Kept out of the component so that which peak was labelled, and at what pixel,
+ * is worth a test that no browser has to stand by for.
+ */
+import { chartPixel, chartValue } from "../../chart/core/chartScale.js";
+import { PEAK_LABEL } from "../../chart/core/chartTheme.js";
+import { labelStackBaselines } from "../../chart/core/labelStack.js";
+import { labelStackBox } from "./labelStackBox.js";
+import { selectLabelledPeaks } from "./labelledPeaks.js";
+import { peakKey, peakLabelLines } from "./peakLabelLines.js";
+/** The clear space kept between two stacks standing side by side. */
+export const LABEL_SPACING = 4;
+/**
+ * Plan the stacks for the window on screen.
+ *
+ * The crowding is settled before a single line is composed, and settled in
+ * descending intensity: the tallest peak of the window asks for its stretch of
+ * the axis first and keeps it, and every fainter peak standing closer than a
+ * label is wide loses its `labelX`. What comes back is in ascending m/z, so the
+ * drawing order is the axis order and a stack keeps its key from one render to
+ * the next.
+ * @param options - The spectrum, the axes, and what the stacks may say.
+ * @returns One plan per peak that earned a label, in ascending m/z, those
+ * crowded out among them.
+ */
+export function planPeakLabels(options) {
+    const { spectrum, plot, xScale, yScale, limit, showCharges = false, mzDecimals, annotationLabels, below = false, intensityScale = 1, } = options;
+    const peaks = selectLabelledPeaks(spectrum, {
+        from: chartValue(xScale, plot.left),
+        to: chartValue(xScale, plot.right),
+        // The far edge of the half this spectrum is drawn in: the top of the plot
+        // for an ordinary chart, its bottom for a half drawn through a reflected
+        // scale.
+        maxValue: chartValue(yScale, below ? plot.bottom : plot.top),
+        ...(limit === undefined ? {} : { limit }),
+    });
+    if (peaks.length === 0)
+        return [];
+    const centres = placeStacks(peaks, plot, xScale);
+    const bounds = [plot.top, plot.bottom];
+    const plans = [];
+    for (let index = 0; index < peaks.length; index++) {
+        const peak = peaks[index];
+        const key = peakKey(spectrum.id, peak.index);
+        const lines = peakLabelLines(peak, {
+            ...(mzDecimals === undefined ? {} : { mzDecimals }),
+            showCharges,
+            intensityScale,
+            ...(annotationLabels === undefined
+                ? {}
+                : { annotationLabel: annotationLabels.get(key) }),
+        });
+        const tipY = chartPixel(yScale, peak.y);
+        const labelX = centres[index];
+        const baselines = labelStackBaselines(tipY, lines.length, bounds, below);
+        plans.push({
+            peak,
+            key,
+            tipX: chartPixel(xScale, peak.x),
+            tipY,
+            labelX,
+            lines,
+            baselines,
+            box: labelStackBox(labelX, baselines),
+        });
+    }
+    return plans;
+}
+/**
+ * Where each stack may stand, `NaN` for one crowded out by a taller peak.
+ *
+ * A stack whose peak stands at the very edge of the plot is slid back inside it
+ * and never further, which is a different thing from clearing a neighbour: the
+ * mark stays on the stick, the number moves by a few pixels rather than by its
+ * own width, and what it avoids is being written half over the axis.
+ * @param peaks - The peaks that earned a label, in ascending m/z.
+ * @param plot - Where the plot sits inside the SVG.
+ * @param xScale - The m/z axis as it is currently zoomed.
+ * @returns The centre each stack was given, indexed as the peaks are.
+ */
+function placeStacks(peaks, plot, xScale) {
+    const half = PEAK_LABEL.hoverHalfWidth;
+    const step = half * 2 + LABEL_SPACING;
+    // A plot too narrow to hold one whole label has no inside to slide anything
+    // back into, and the clamp would put every stack in the same place.
+    const roomy = plot.width >= half * 2;
+    const centres = new Float64Array(peaks.length).fill(Number.NaN);
+    const placed = [];
+    for (const index of tallestFirst(peaks)) {
+        const wanted = chartPixel(xScale, peaks[index].x);
+        const centre = roomy
+            ? Math.min(Math.max(wanted, plot.left + half), plot.right - half)
+            : wanted;
+        if (!clearOfPlaced(placed, centre, step))
+            continue;
+        placed.push(centre);
+        centres[index] = centre;
+    }
+    return centres;
+}
+/**
+ * The indices of the peaks, the tallest first — the order the room is handed
+ * out in, so that a base peak is labelled on every chart it appears on.
+ * @param peaks - The peaks that earned a label.
+ * @returns Their indices, descending by intensity.
+ */
+function tallestFirst(peaks) {
+    const order = new Uint32Array(peaks.length);
+    for (let index = 0; index < peaks.length; index++)
+        order[index] = index;
+    return order.toSorted((first, second) => peaks[second].y - peaks[first].y);
+}
+/**
+ * Whether a stack may stand where it wants to, given the ones already placed.
+ * @param placed - The centres already given out, in pixels.
+ * @param centre - The centre being asked for.
+ * @param step - How far apart two centres have to be for both to be readable.
+ * @returns Whether it clears every one of them.
+ */
+function clearOfPlaced(placed, centre, step) {
+    for (const taken of placed) {
+        if (Math.abs(taken - centre) < step)
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=peakLabelPlan.js.map

package/lib/mass/core/peakLabelPlan.js.map

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

package/lib/mass/core/peakTable.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The rows the peak table lists, and the text they are copied out as.
+ *
+ * The rows are the centroid's own peaks, read through `selectCentroidPeaks` —
+ * the same windowing the chart is read through — so the table and the chart
+ * can never disagree about which peaks exist.
+ */
+import type { MassPeakObject } from './centroidPeaks.ts';
+import type { MassDomain, MassSpectrum } from './massSpectrum.ts';
+/**
+ * How many rows the table lists at most, the most intense kept.
+ *
+ * Far more than anybody reads, and few enough that a centroid of fifty
+ * thousand peaks does not lay out fifty thousand rows under a pointer move.
+ */
+export declare const PEAK_TABLE_LIMIT = 1000;
+/**
+ * The floor the table starts at, as a fraction of the base peak: where a
+ * chemist's own peak list starts, and where everything under it is the
+ * baseline the compound sits on.
+ */
+export declare const PEAK_TABLE_THRESHOLD = 0.01;
+/** Which peaks the table lists. */
+export interface PeakTableOptions {
+    /**
+     * The window the chart shows, when the table is to follow it; `null` for the
+     * whole spectrum.
+     * @default null
+     */
+    domain?: MassDomain | null;
+    /**
+     * The floor, as a fraction of the base peak; `0` lists every peak.
+     * @default PEAK_TABLE_THRESHOLD
+     */
+    threshold?: number;
+}
+/**
+ * The peaks the table lists for one spectrum, in increasing m/z.
+ * @param spectrum - The spectrum the table is about.
+ * @param options - The window, and the floor.
+ * @returns The peaks, shared with the centroid's cache — read, never written.
+ */
+export declare function peakTableRows(spectrum: MassSpectrum, options?: PeakTableOptions): MassPeakObject[];
+/**
+ * The rows as tab-separated text, the way a spreadsheet takes a paste.
+ *
+ * Written to the decimals the table shows rather than as the doubles are held,
+ * so what is pasted is what was read on screen.
+ * @param peaks - The rows, in the order they are listed.
+ * @param mzDecimals - How many decimals the masses are written with.
+ * @returns A header line and one line per peak.
+ */
+export declare function peakTableToTsv(peaks: readonly MassPeakObject[], mzDecimals: number): string;
+//# sourceMappingURL=peakTable.d.ts.map

package/lib/mass/core/peakTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peakTable.d.ts","sourceRoot":"","sources":["../../../src/mass/core/peakTable.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGzD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAElE;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,OAAO,CAAC;AAErC;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,OAAO,CAAC;AAEzC,mCAAmC;AACnC,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,MAAM,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IAC3B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,YAAY,EACtB,OAAO,GAAE,gBAAqB,GAC7B,cAAc,EAAE,CAOlB;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,SAAS,cAAc,EAAE,EAChC,UAAU,EAAE,MAAM,GACjB,MAAM,CAQR"}