react-cheminfo 0.69.0 → 0.71.0

package/lib/mass/core/massResolution.js

@@ -0,0 +1,126 @@
+/**
+ * Whether a spectrum resolves masses finely enough for their decimals to mean
+ * anything.
+ *
+ * A peak table typed out of a low-resolution instrument report holds whole
+ * numbers — `163`, `325`, `487` — and writing them as `163.0000` claims four
+ * digits of accuracy nobody measured. A high-resolution measurement is the
+ * opposite case: `325.1129` and `325.1503` are different ions, and rounding them
+ * together loses the whole point of having measured them. Nothing about a single
+ * number says which of the two it is, so the answer is read off the spectrum.
+ *
+ * Three kinds of evidence are read, and the strongest one present decides —
+ * `decideResolution` is where they are weighed:
+ *
+ * 1. **The peaks themselves.** A profile carries the width of every peak, and
+ *    the resolving power `m / Δm` at half height is what "high resolution" is
+ *    defined by. This is a measurement, so it is believed over anything a file
+ *    says about itself.
+ * 2. **What the file says the instrument was.** A Thermo scan filter starting
+ *    `FTMS` is an Orbitrap, one starting `ITMS` an ion trap, and a JCAMP of the
+ *    old MS dialect writes `##.INSTRUMENT PARAMETERS= LOW RESOLUTION` outright.
+ * 3. **How many decimals the masses were written with**, which is all a bare
+ *    peak table has to say — `writtenResolution.ts`.
+ */
+import { gaussianWidthToFWHM } from 'ml-peak-shape-generator';
+import { xMedian } from 'ml-spectra-processing';
+/**
+ * The resolving power from which a spectrum counts as high resolution.
+ *
+ * Ten thousand at half height is the conventional threshold, and it falls in
+ * the gap between the two families of instrument rather than inside either:
+ * quadrupoles, ion traps and linear time-of-flights work at a few thousand at
+ * most, while reflectron time-of-flights, Orbitraps and FT-ICRs start above it.
+ */
+export const HIGH_RESOLVING_POWER = 10_000;
+/** How many of the tallest peaks the resolving power is the median of. */
+export const MEASURED_PEAKS = 20;
+/** How many decimals an m/z is written with, for each kind of spectrum. */
+export const MZ_DECIMALS = {
+    high: 4,
+    low: 1,
+    nominal: 0,
+};
+/**
+ * The resolving power measured on the peaks of a profile.
+ *
+ * The median over the tallest peaks rather than over all of them, because a
+ * peak a few counts above the noise has a width the noise decided, and rather
+ * than the base peak alone, because one peak sitting on an unresolved shoulder
+ * would decide the whole spectrum. The width `ml-gsd` reports is the distance
+ * between the inflection points, which is converted to the width at half height
+ * as a gaussian's is: what a resolving power is quoted against.
+ * @param peaks - The peaks the profile was picked into, each with its width.
+ * @returns The verdict, `null` when no peak carries a usable width.
+ */
+export function measuredResolution(peaks) {
+    const usable = [];
+    for (const peak of peaks) {
+        if (peak.x > 0 && peak.width > 0 && Number.isFinite(peak.width)) {
+            usable.push(peak);
+        }
+    }
+    if (usable.length === 0)
+        return null;
+    const tallest = usable
+        .toSorted((first, second) => second.y - first.y)
+        .slice(0, MEASURED_PEAKS);
+    const powers = new Float64Array(tallest.length);
+    for (let index = 0; index < tallest.length; index++) {
+        const peak = tallest[index];
+        powers[index] = peak.x / gaussianWidthToFWHM(peak.width);
+    }
+    const resolvingPower = xMedian(powers);
+    const kind = resolvingPower >= HIGH_RESOLVING_POWER ? 'high' : 'low';
+    return {
+        kind,
+        resolvingPower,
+        basis: 'peakWidth',
+        decimals: MZ_DECIMALS[kind],
+    };
+}
+/**
+ * The resolution the file says the instrument worked at, when it says so.
+ *
+ * Only the rows that name an instrument are read, and a high verdict is looked
+ * for first: an `LTQ-Orbitrap` names an ion trap and an Orbitrap, and the
+ * spectrum came out of the Orbitrap. A time-of-flight is deliberately left
+ * undecided — a reflectron one is high resolution and a linear one is not, and
+ * the name is the same.
+ * @param meta - What the file said about the acquisition.
+ * @returns The verdict, `null` when the file names no instrument it can be
+ * read off.
+ */
+export function statedResolution(meta) {
+    if (meta === null)
+        return null;
+    for (const field of meta.fields) {
+        if (!INSTRUMENT_FIELDS.has(field.label))
+            continue;
+        const kind = HIGH_INSTRUMENT.test(field.value)
+            ? 'high'
+            : LOW_INSTRUMENT.test(field.value)
+                ? 'low'
+                : null;
+        if (kind !== null) {
+            return {
+                kind,
+                resolvingPower: null,
+                basis: 'instrument',
+                decimals: MZ_DECIMALS[kind],
+            };
+        }
+    }
+    return null;
+}
+/** The acquisition rows that name the instrument, and so its resolution. */
+const INSTRUMENT_FIELDS = new Set([
+    'Analyser',
+    'Instrument',
+    'Instrument parameters',
+]);
+/** The instruments, and the words, that say high resolution. */
+const HIGH_INSTRUMENT = /\bHIGH[\s-]RESOLUTION\b|\bHRMS\b|\bFTMS\b|ORBITRAP|\bFT-?ICR\b|\bEXACTIVE\b|\bEXPLORIS\b/i;
+/** The instruments, and the words, that say a unit-resolution measurement. */
+const LOW_INSTRUMENT = /\bLOW[\s-]RESOLUTION\b|\bITMS\b|\bION[\s-]TRAP\b|\bTRAP\b|QUADRUPOLE/i;
+//# sourceMappingURL=massResolution.js.map

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

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

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

@@ -0,0 +1,28 @@
+/**
+ * The panels the side of the viewer can hold, in the order their icons stack.
+ *
+ * One frozen list read by both the activity bar and the panel stack, so a panel
+ * switched off and on again comes back where it was rather than at the end.
+ */
+export declare const massSidePanels: readonly [{
+    readonly id: "spectra";
+    readonly title: "Spectra";
+    readonly icon: "timeline-line-chart";
+}, {
+    readonly id: "peaks";
+    readonly title: "Peaks";
+    readonly icon: "th-list";
+}, {
+    readonly id: "metadata";
+    readonly title: "Acquisition";
+    readonly icon: "properties";
+}];
+/** Identity of one of the panels the viewer offers of its own. */
+export type MassSidePanelId = (typeof massSidePanels)[number]['id'];
+/**
+ * Identity of any panel the side can hold: one of the viewer's own, or one a
+ * host added to them. Still a union with the viewer's own ids, so those keep
+ * autocompleting where a plain `string` would swallow them.
+ */
+export type MassPanelId = MassSidePanelId | (string & Record<never, never>);
+//# sourceMappingURL=massSidePanels.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"massSidePanels.d.ts","sourceRoot":"","sources":["../../../src/mass/core/massSidePanels.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;EAQzB,CAAC;AAEH,kEAAkE;AAClE,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC;AAEpE;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,eAAe,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC"}

package/lib/mass/core/massSidePanels.js

@@ -0,0 +1,12 @@
+/**
+ * The panels the side of the viewer can hold, in the order their icons stack.
+ *
+ * One frozen list read by both the activity bar and the panel stack, so a panel
+ * switched off and on again comes back where it was rather than at the end.
+ */
+export const massSidePanels = [
+    { id: 'spectra', title: 'Spectra', icon: 'timeline-line-chart' },
+    { id: 'peaks', title: 'Peaks', icon: 'th-list' },
+    { id: 'metadata', title: 'Acquisition', icon: 'properties' },
+];
+//# sourceMappingURL=massSidePanels.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"massSidePanels.js","sourceRoot":"","sources":["../../../src/mass/core/massSidePanels.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,qBAAqB,EAAE;IAChE,EAAE,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE;IAChD,EAAE,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,YAAY,EAAE;CAK5D,CAAC"}

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

@@ -0,0 +1,206 @@
+/**
+ * What a mass spectrum is once it has been read, whatever it was read from.
+ *
+ * A file gives one or more acquisitions; each becomes one `MassSpectrum` with
+ * two traces of the same measurement — the continuous `profile` as the
+ * instrument recorded it, and the `centroid` the peak picking reduced it to.
+ * Both are kept because they answer different questions: the profile is what a
+ * chemist recognises as a spectrum, and the centroid is what every number
+ * downstream is computed from. A centroided file has no profile, and that is
+ * the normal case for a peak table pasted out of an instrument report.
+ *
+ * The arrays are `Float64Array` throughout and are never converted to
+ * `number[]`: a profile scan runs to hundreds of thousands of points, a plain
+ * array costs two to three times the memory, and any structural freeze or
+ * spread walks it element by element while treating a typed array as atomic.
+ * They are replaced on a change, never written into, since every consumer holds
+ * the same object by reference.
+ *
+ * The shape is the one the glycan site's mass viewer holds, field for field
+ * where the two overlap, so a spectrum that viewer built can be handed to
+ * anything here: whatever it carries beyond these fields is simply not read.
+ */
+import type { DataXY } from 'cheminfo-types';
+import type { ChartDomain } from '../../chart/core/chartDomain.ts';
+import type { MassResolution } from './massResolution.ts';
+/**
+ * One trace of a measurement: m/z against intensity, x strictly increasing.
+ *
+ * `DataXY` is the shape every package in this pipeline speaks — `xy-parser`,
+ * `ms-spectrum` and `ml-spectra-processing` all take and return it — so
+ * declaring a parallel type of our own would buy nothing and cost an adapter at
+ * each boundary.
+ */
+export type MassTrace = DataXY<Float64Array>;
+/**
+ * The picked peaks of a spectrum, with the charge of each.
+ *
+ * `charge` is a dense column rather than an array of optional numbers so it
+ * costs two bytes a peak and needs no per-peak object: `0` means no charge was
+ * established, which is an answer rather than a missing value — a peak belongs
+ * to no isotopologue cluster and to no charge ladder. A charge is never read
+ * off a single peak, only off the series it belongs to.
+ */
+export interface MassPeaks extends MassTrace {
+    /** Charge of each peak, `0` where none was established. Signed. */
+    charge: Int16Array;
+}
+/**
+ * The formats a spectrum can have been read from.
+ *
+ * The two this package reads, and `calculated` for a trace nobody measured. Any
+ * other name is accepted as well, because a host that read an mzML with a
+ * reader of its own hands the spectrum over still knowing what it was read
+ * from, and the acquisition table should say so rather than call it text.
+ */
+export type MassFormat = 'jcamp' | 'text' | 'calculated' | (string & Record<never, never>);
+/**
+ * Where a spectrum came from, and what the file said about the acquisition.
+ *
+ * Kept apart from `meta` because these are the facts other code branches on —
+ * a calculated trace is never reduced for drawing, an MS2 scan carries a
+ * precursor worth showing beside its name — while `meta` is a table to read.
+ * The readers of this package leave the acquisition facts out; a host whose
+ * reader states them, an mzML's, hands them over here.
+ */
+export interface MassOrigin {
+    /** The format it was read from. */
+    format: MassFormat;
+    /**
+     * Name of the file it came from, absent for a paste.
+     * @default undefined
+     */
+    fileName?: string;
+    /**
+     * Which acquisition of that file, counted from zero — the block of a JCAMP,
+     * or the page of a GC/MS one — absent when the file held only one.
+     * @default undefined
+     */
+    scanIndex?: number;
+    /**
+     * MS level: 1 for a survey scan, 2 for a fragmentation scan.
+     * @default undefined
+     */
+    msLevel?: number;
+    /**
+     * Polarity the scan was acquired in.
+     * @default undefined
+     */
+    polarity?: 'positive' | 'negative';
+    /**
+     * The m/z that was isolated and fragmented, on an MS2 scan.
+     * @default undefined
+     */
+    precursorMz?: number;
+    /**
+     * The monoisotopic m/z the instrument named for that precursor, where it
+     * named one.
+     *
+     * Carried beside the precursor rather than instead of it because the two are
+     * the same number on nearly every scan that has both, and a different one on
+     * a scan whose method offset its isolation window: the precursor is then the
+     * centre of the window, since that is what the quadrupole transmitted, and
+     * this is the molecule the method was after.
+     * @default undefined
+     */
+    precursorMonoisotopicMz?: number;
+    /**
+     * Retention time in minutes, on a scan out of a chromatographic run.
+     * @default undefined
+     */
+    retentionTime?: number;
+}
+/** One row of the acquisition table. */
+export interface MassMetaField {
+    /** How the row is named, in the display order the table fixes. */
+    label: string;
+    /** The value as the file states it. */
+    value: string;
+}
+/**
+ * What the file says about how the spectrum was acquired.
+ *
+ * Only ever what it actually says: a field the file leaves blank is left out
+ * rather than shown empty, so the table is short and every line in it is a
+ * fact. A plain two-column paste carries none of this, which is most pastes,
+ * and the panel then shows the file name alone.
+ */
+export interface MassMeta {
+    /** The title record, `null` when the file carries none. */
+    title: string | null;
+    /** The molecular formula the file claims, `null` when it claims none. */
+    molecularFormula: string | null;
+    /** The fields that are populated, in display order. */
+    fields: MassMetaField[];
+    /**
+     * The instrument's own scan description, kept verbatim. Real instruments
+     * leave the structured records empty and put the answer only here, so it is
+     * both the fallback the fields are mined from and worth showing as written.
+     */
+    conditions: string | null;
+}
+/** One spectrum as the viewer holds it. */
+export interface MassSpectrum {
+    /** Identity, stable across edits so a selection survives a rename. */
+    id: string;
+    /** What the list calls it; editable, and never used as identity. */
+    name: string;
+    /** The colour both its traces are drawn in. */
+    color: string;
+    /** The continuous trace, `null` when the file was already centroided. */
+    profile: MassTrace | null;
+    /** The picked peaks, which every number downstream is computed from. */
+    centroid: MassPeaks;
+    /** What the file said about the acquisition, `null` when it said nothing. */
+    meta: MassMeta | null;
+    /** Where it came from. */
+    origin: MassOrigin;
+    /**
+     * Whether the profile is drawn. The viewer draws one trace or the other and
+     * never both; `isSpectrumDrawn` is the question to ask about the pair.
+     */
+    showProfile: boolean;
+    /** Whether the centroid sticks are drawn, under the same rule. */
+    showCentroid: boolean;
+    /**
+     * Whether the trace is left out of the automatic domain. A predicted
+     * distribution previewed under the pointer must not move the axes, or hovering
+     * a candidate would throw away the zoom the user set.
+     * @default false
+     */
+    excludeFromDomain?: boolean;
+    /**
+     * How finely the spectrum resolves masses, as it was decided when it was read.
+     *
+     * Left out by a host that built the spectrum itself, and then worked out from
+     * the masses as written — see `resolutionOf`.
+     * @default undefined
+     */
+    resolution?: MassResolution;
+}
+/**
+ * The window the chart is showing, in data units.
+ *
+ * `ChartDomain` itself, not a type of our own: the arithmetic that moves a
+ * window is the shared chart's and speaks that type, and an alias here that
+ * merely renamed it would need converting at every call. `x` is in m/z and `y`
+ * in intensity.
+ */
+export type MassDomain = ChartDomain;
+/**
+ * Whether a spectrum is on the chart at all, by whichever of its traces.
+ *
+ * A spectrum is drawn as its profile *or* as its sticks and never as both — a
+ * centroid standing inside the peak shapes it was picked from reads as a second
+ * spectrum laid over the first — so whether it is on screen is a question about
+ * the pair and not about either one.
+ *
+ * This is what everything that *uses* the picked peaks asks: pointing at a peak,
+ * labelling one, listing them. All of them read the centroid whether or not the
+ * sticks are the trace being drawn, so asking `showCentroid` there would make a
+ * spectrum shown as its profile quietly stop answering anything.
+ * @param spectrum - The spectrum.
+ * @returns Whether either of its traces is drawn.
+ */
+export declare function isSpectrumDrawn(spectrum: MassSpectrum): boolean;
+//# sourceMappingURL=massSpectrum.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"massSpectrum.d.ts","sourceRoot":"","sources":["../../../src/mass/core/massSpectrum.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAEnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D;;;;;;;GAOG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;AAE7C;;;;;;;;GAQG;AACH,MAAM,WAAW,SAAU,SAAQ,SAAS;IAC1C,mEAAmE;IACnE,MAAM,EAAE,UAAU,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,GACpB,OAAO,GAAG,MAAM,GAAG,YAAY,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;AAEpE;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU;IACzB,mCAAmC;IACnC,MAAM,EAAE,UAAU,CAAC;IACnB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,QAAQ,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IACnC;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;;;;OAUG;IACH,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,wCAAwC;AACxC,MAAM,WAAW,aAAa;IAC5B,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC;IACd,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB,2DAA2D;IAC3D,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,yEAAyE;IACzE,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,uDAAuD;IACvD,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB;;;;OAIG;IACH,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,2CAA2C;AAC3C,MAAM,WAAW,YAAY;IAC3B,sEAAsE;IACtE,EAAE,EAAE,MAAM,CAAC;IACX,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,OAAO,EAAE,SAAS,GAAG,IAAI,CAAC;IAC1B,wEAAwE;IACxE,QAAQ,EAAE,SAAS,CAAC;IACpB,6EAA6E;IAC7E,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;IACtB,0BAA0B;IAC1B,MAAM,EAAE,UAAU,CAAC;IACnB;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB,kEAAkE;IAClE,YAAY,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,cAAc,CAAC;CAC7B;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC;AAErC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAE/D"}

package/lib/mass/core/massSpectrum.js

@@ -0,0 +1,41 @@
+/**
+ * What a mass spectrum is once it has been read, whatever it was read from.
+ *
+ * A file gives one or more acquisitions; each becomes one `MassSpectrum` with
+ * two traces of the same measurement — the continuous `profile` as the
+ * instrument recorded it, and the `centroid` the peak picking reduced it to.
+ * Both are kept because they answer different questions: the profile is what a
+ * chemist recognises as a spectrum, and the centroid is what every number
+ * downstream is computed from. A centroided file has no profile, and that is
+ * the normal case for a peak table pasted out of an instrument report.
+ *
+ * The arrays are `Float64Array` throughout and are never converted to
+ * `number[]`: a profile scan runs to hundreds of thousands of points, a plain
+ * array costs two to three times the memory, and any structural freeze or
+ * spread walks it element by element while treating a typed array as atomic.
+ * They are replaced on a change, never written into, since every consumer holds
+ * the same object by reference.
+ *
+ * The shape is the one the glycan site's mass viewer holds, field for field
+ * where the two overlap, so a spectrum that viewer built can be handed to
+ * anything here: whatever it carries beyond these fields is simply not read.
+ */
+/**
+ * Whether a spectrum is on the chart at all, by whichever of its traces.
+ *
+ * A spectrum is drawn as its profile *or* as its sticks and never as both — a
+ * centroid standing inside the peak shapes it was picked from reads as a second
+ * spectrum laid over the first — so whether it is on screen is a question about
+ * the pair and not about either one.
+ *
+ * This is what everything that *uses* the picked peaks asks: pointing at a peak,
+ * labelling one, listing them. All of them read the centroid whether or not the
+ * sticks are the trace being drawn, so asking `showCentroid` there would make a
+ * spectrum shown as its profile quietly stop answering anything.
+ * @param spectrum - The spectrum.
+ * @returns Whether either of its traces is drawn.
+ */
+export function isSpectrumDrawn(spectrum) {
+    return spectrum.showProfile || spectrum.showCentroid;
+}
+//# sourceMappingURL=massSpectrum.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"massSpectrum.js","sourceRoot":"","sources":["../../../src/mass/core/massSpectrum.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAqLH;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,eAAe,CAAC,QAAsB;IACpD,OAAO,QAAQ,CAAC,WAAW,IAAI,QAAQ,CAAC,YAAY,CAAC;AACvD,CAAC"}

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

@@ -0,0 +1,145 @@
+/**
+ * Everything the viewer knows, in the three buckets NMRium splits its own into
+ * — the same three the infrared viewer holds, under the same names.
+ *
+ * The split is the persistence boundary as much as anything: `data` is the
+ * document, `view` is where you are in it and lasts as long as the session, and
+ * `settings` is the workspace, which is how every spectrum is drawn whichever
+ * ones happen to be open.
+ *
+ * The peaks are in `data`, each spectrum carrying its own centroid: picked once,
+ * when the spectrum was read, so nothing about drawing it ever picks again.
+ */
+import type { MassPanelId, MassSidePanelId } from './massSidePanels.ts';
+import type { MassDomain, MassSpectrum } from './massSpectrum.ts';
+import type { MzDecimalsSetting } from './mzDecimalsSetting.ts';
+/** The document: what the files held. */
+export interface MassData {
+    /** The spectra, in the order they were loaded. */
+    spectra: MassSpectrum[];
+}
+/** What a drag across the chart is for while it is chosen. */
+export type MassTool = 'read' | 'box';
+/** Where you are in the viewer. */
+export interface MassView {
+    /** Identity of the spectrum the panels act on, `null` for none. */
+    selectedId: string | null;
+    /**
+     * The window being shown, `null` while the chart is showing what fits.
+     *
+     * Held here so that a toolbar button and a row of the peak table can zoom —
+     * the chart is told a window and reports every window it arrives at, and this
+     * is where the answer lives between the two.
+     */
+    domain: MassDomain | null;
+    /** Which tool a drag across the chart is running. */
+    tool: MassTool;
+    /**
+     * The side panels that are open: the viewer's own and any a host added. An id
+     * no panel on offer answers to opens nothing.
+     */
+    openPanelIds: MassPanelId[];
+    /** Why the last action was refused, `null` as soon as one succeeds. */
+    error: string | null;
+}
+/** The workspace: how every spectrum is drawn, whichever ones are open. */
+export interface MassSettings {
+    /** Whether the peaks of the selected spectrum are labelled on the chart. */
+    showLabels: boolean;
+    /** At most how many peaks are labelled at once. */
+    labelLimit: number;
+    /** Whether a label writes the charge of a peak whose charge was established. */
+    showCharges: boolean;
+    /**
+     * How many decimals the masses on screen are written with: `'auto'` for what
+     * the spectra resolve — high-resolution masses or nominal ones — or the
+     * number the reader chose.
+     */
+    mzDecimals: MzDecimalsSetting;
+}
+/** Everything the viewer knows. */
+export interface MassState {
+    /** The spectra that are open. */
+    data: MassData;
+    /** Where you are in the viewer. */
+    view: MassView;
+    /** How spectra are drawn. */
+    settings: MassSettings;
+}
+/** Part of a state, as a host restoring one supplies it. */
+export interface PartialMassState {
+    /** The spectra that were open. */
+    data?: MassData;
+    /** Where the viewer was left. */
+    view?: Partial<MassView>;
+    /** The workspace they were drawn in. */
+    settings?: Partial<MassSettings>;
+}
+/** The panel the splitter brings back when it is dragged open on nothing. */
+export declare const DEFAULT_SIDE_PANEL: MassSidePanelId;
+/**
+ * The panels a fresh viewer opens with: the list, and the peaks of whichever
+ * spectrum is selected in it, because a spectrum is read through its peaks.
+ */
+export declare const DEFAULT_SIDE_PANELS: MassSidePanelId[];
+/** How many peaks are labelled to begin with. */
+export declare const DEFAULT_LABEL_LIMIT = 20;
+/** At most how many peaks a setting may ask to have labelled. */
+export declare const MAXIMUM_LABEL_LIMIT = 500;
+/** The workspace a fresh viewer starts from. */
+export declare const DEFAULT_SETTINGS: MassSettings;
+/** What a viewer opens on. */
+export interface CreateMassStateOptions {
+    /**
+     * The spectra to open on.
+     * @default []
+     */
+    spectra?: MassSpectrum[];
+    /**
+     * The workspace to open in.
+     * @default DEFAULT_SETTINGS
+     */
+    settings?: Partial<MassSettings>;
+    /**
+     * The panels open to begin with, the viewer's own or a host's.
+     * @default DEFAULT_SIDE_PANELS
+     */
+    panelIds?: readonly MassPanelId[];
+}
+/**
+ * The state a viewer opens with.
+ *
+ * The panel list is spread rather than stored by reference: a caller's array is
+ * the caller's to mutate, and a viewer holding it would find its open panels
+ * changing under it.
+ * @param options - What it opens on.
+ * @returns The state.
+ */
+export declare function createMassState(options?: CreateMassStateOptions): MassState;
+/**
+ * Fold a change into the workspace, refusing what no chart survives.
+ *
+ * A number typed into a field arrives here as `NaN` for every keystroke that is
+ * not yet a number — a lone minus sign, an empty box — and a limit of `NaN`
+ * silently stops every label being drawn. So the limit is checked, and the
+ * current value kept where the new one is unusable rather than the field being
+ * fought with while it is being typed in. The decimals are read back the same
+ * way, through `readMzDecimalsSetting`, since a stored workspace is no more to
+ * be trusted than a half-typed field.
+ * @param current - The workspace in force.
+ * @param change - What to change about it.
+ * @returns The new workspace.
+ */
+export declare function mergeMassSettings(current: MassSettings, change?: Partial<MassSettings>): MassSettings;
+/**
+ * Whether a window is one a chart can be built on.
+ *
+ * Both ends finite and the low one below the high one. A window failing either
+ * makes every scale built from it infinite, which the DOM refuses outright — so
+ * a handle told to frame a peak it worked out wrongly leaves the chart alone
+ * instead of blanking it.
+ * @param domain - The window to check.
+ * @returns Whether it can be shown.
+ */
+export declare function isMassWindow(domain: MassDomain): boolean;
+//# sourceMappingURL=massState.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"massState.d.ts","sourceRoot":"","sources":["../../../src/mass/core/massState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAGhE,yCAAyC;AACzC,MAAM,WAAW,QAAQ;IACvB,kDAAkD;IAClD,OAAO,EAAE,YAAY,EAAE,CAAC;CACzB;AAED,8DAA8D;AAC9D,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;AAEtC,mCAAmC;AACnC,MAAM,WAAW,QAAQ;IACvB,mEAAmE;IACnE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;;;;;;OAMG;IACH,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IAC1B,qDAAqD;IACrD,IAAI,EAAE,QAAQ,CAAC;IACf;;;OAGG;IACH,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,uEAAuE;IACvE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,2EAA2E;AAC3E,MAAM,WAAW,YAAY;IAC3B,4EAA4E;IAC5E,UAAU,EAAE,OAAO,CAAC;IACpB,mDAAmD;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,gFAAgF;IAChF,WAAW,EAAE,OAAO,CAAC;IACrB;;;;OAIG;IACH,UAAU,EAAE,iBAAiB,CAAC;CAC/B;AAED,mCAAmC;AACnC,MAAM,WAAW,SAAS;IACxB,iCAAiC;IACjC,IAAI,EAAE,QAAQ,CAAC;IACf,mCAAmC;IACnC,IAAI,EAAE,QAAQ,CAAC;IACf,6BAA6B;IAC7B,QAAQ,EAAE,YAAY,CAAC;CACxB;AAED,4DAA4D;AAC5D,MAAM,WAAW,gBAAgB;IAC/B,kCAAkC;IAClC,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,iCAAiC;IACjC,IAAI,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IACzB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;CAClC;AAED,6EAA6E;AAC7E,eAAO,MAAM,kBAAkB,EAAE,eAA2B,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,eAAe,EAAyB,CAAC;AAE3E,iDAAiD;AACjD,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,iEAAiE;AACjE,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAEvC,gDAAgD;AAChD,eAAO,MAAM,gBAAgB,EAAE,YAK9B,CAAC;AAEF,8BAA8B;AAC9B,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;IACzB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;CACnC;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,OAAO,GAAE,sBAA2B,GACnC,SAAS,CAaX;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,YAAY,EACrB,MAAM,GAAE,OAAO,CAAC,YAAY,CAAM,GACjC,YAAY,CAUd;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAExD"}