react-cheminfo 0.28.0 → 0.30.0

package/lib/chart/core/selectionGeometry.js

@@ -0,0 +1,49 @@
+/**
+ * The rectangle a drag sweeps out, in the pixels it is drawn in.
+ *
+ * The preview and the release are two readings of one gesture, and they have to
+ * agree: a rectangle that promises a window the release then refuses teaches a
+ * user that the chart is unreliable, which is a far more expensive mistake than
+ * a preview that is a pixel out. So the same two tests decide both — the drag is
+ * pulled back inside the plot and measured against `MINIMUM_DRAG` here exactly
+ * as `zoomedDomain` does it, and the height comes from the answer
+ * `zoomSelection` already worked out rather than from a second one.
+ */
+import { clamp } from "../../format/core/clamp.js";
+import { MINIMUM_DRAG } from "./zoomDomain.js";
+/**
+ * The rectangle to draw for a drag being made.
+ *
+ * A drag that takes the y axis with it is drawn at the height of the drag
+ * itself, and one that asks for the x axis alone spans the whole plot.
+ * That is the gesture announcing itself before the button is let go: the
+ * rectangle changing shape as the pointer crosses the baseline is the only
+ * warning a user gets that the release is about to move both axes, and it is one
+ * they can still act on.
+ *
+ * A drag too short to zoom draws nothing at all. Below `MINIMUM_DRAG` the
+ * release does nothing — most clicks made on a trackpad wobble by a pixel or two
+ * — and a rectangle flashing up on every click would say that something
+ * happened.
+ * @param selection - The drag being made, `null` when none is.
+ * @param plot - Where the plot sits inside the SVG, which the drag is confined
+ * to.
+ * @returns The rectangle, `null` when there is nothing to draw.
+ */
+export function selectionRectangle(selection, plot) {
+    if (selection === null)
+        return null;
+    const { fromX, toX, fromY, toY, zoomsYAxis } = selection;
+    const left = clamp(Math.min(fromX, toX), plot.left, plot.right);
+    const right = clamp(Math.max(fromX, toX), plot.left, plot.right);
+    const width = right - left;
+    if (!(width >= MINIMUM_DRAG))
+        return null;
+    if (!zoomsYAxis) {
+        return { x: left, y: plot.top, width, height: plot.height };
+    }
+    const top = clamp(Math.min(fromY, toY), plot.top, plot.bottom);
+    const bottom = clamp(Math.max(fromY, toY), plot.top, plot.bottom);
+    return { x: left, y: top, width, height: bottom - top };
+}
+//# sourceMappingURL=selectionGeometry.js.map

package/lib/chart/core/selectionGeometry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectionGeometry.js","sourceRoot":"","sources":["../../../src/chart/core/selectionGeometry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAInD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAc/C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,kBAAkB,CAChC,SAA+B,EAC/B,IAAc;IAEd,IAAI,SAAS,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAEpC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,GAAG,SAAS,CAAC;IACzD,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAChE,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IACjE,MAAM,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC;IAC3B,IAAI,CAAC,CAAC,KAAK,IAAI,YAAY,CAAC;QAAE,OAAO,IAAI,CAAC;IAE1C,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;IAC9D,CAAC;IACD,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAC/D,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAClE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,EAAE,CAAC;AAC1D,CAAC"}

package/lib/chart/core/spectrumColor.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The colours spectra are told apart by, in two tiers.
+ *
+ * A viewer holds a handful of spectra at a time — a measurement, a reference,
+ * a predicted distribution — so the palette is short and every hue in it is
+ * distinguishable at the width of a one-pixel stick, which is all a centroid
+ * ever is. It is deliberately not a generated scale: named colours stay the same
+ * from one session to the next, and a chemist who calls the blue one "the blank"
+ * is still right tomorrow.
+ *
+ * A colour is the only thing telling one trace from another once they overlap,
+ * so a palette that fails for the one man in twelve with a colour vision
+ * deficiency fails at the only job it has. The matplotlib hues this used to hold
+ * put a red beside a green — the very pair a deuteranope reads as one colour,
+ * and the pair a blank and its sample are most often drawn in.
+ *
+ * That is why there are two tiers rather than one long list. Okabe and Ito's set
+ * is short because it holds only colours that survive **every** deficiency at
+ * once, including the rarer ones where two channels are affected; the Color
+ * Universal Design accent set that the same work grew into is longer because it
+ * asks only that a reader missing **one** channel can tell its members apart.
+ * Both are true, and which one is wanted depends on who is reading the chart, so
+ * the short set is what a chart hands out by itself and the longer one is what a
+ * reader may reach for. Nothing picks a colour out of the second tier on anyone's
+ * behalf.
+ *
+ * Every viewer offers both tiers and none of them keeps a set of its own: two
+ * charts on one page have to name a spectrum the same way, and a palette copied
+ * into a second package is a palette that drifts from the first.
+ */
+/**
+ * The colours a spectrum is drawn in, in the order they are handed out.
+ *
+ * Okabe and Ito's universal set exactly as {@link CHART_SERIES_COLORS} holds
+ * it, less the two a line cannot use: their yellow, which is faint on a white
+ * plot at the width of a stick, and the neutral dark, which is already the ink
+ * of the axes and the labels. Both are still offered, one tier down.
+ *
+ * Derived rather than written out, because a palette copied into a second
+ * place is a palette that drifts from the first: a scatter plot and a spectrum
+ * on the same page have to call the same blue the same blue.
+ *
+ * Blue and vermillion come first because the commonest use is two spectra
+ * compared — the pair that reads most clearly, and the pair a mirror plot
+ * expects.
+ */
+export declare const SPECTRUM_COLORS: readonly string[];
+export declare const EXTRA_SPECTRUM_COLORS: readonly string[];
+/**
+ * Both tiers in one list, the handed-out six first.
+ *
+ * What a picker shows. The order is the tiers in order and never sorted by hue:
+ * a reader who has learnt that the first chip is the blue their blank is drawn
+ * in must find it in the same place in every viewer, and the row a colour sits
+ * in is itself the answer to "will this survive whoever reads the figure".
+ */
+export declare const ALL_SPECTRUM_COLORS: readonly string[];
+/**
+ * The colour to give the next spectrum, given the ones already in use.
+ *
+ * The lowest unused hue, never one derived from how many spectra there are:
+ * dropping the second of three and loading another would otherwise hand out a
+ * colour already on the chart, and two spectra of the same blue is the one
+ * mistake a colour is there to prevent.
+ *
+ * Once every hue is taken it falls to the least-used one, lowest first — the
+ * same rule, since an unused hue is a hue used no times. It never reaches into
+ * the second tier to avoid a repeat: a colour only that reader's eyes can place
+ * is a choice made for them, and a seventh blue they can read beats a brown they
+ * cannot.
+ *
+ * A spectrum a reader has drawn in a second-tier colour counts as holding none
+ * of the six, so it neither uses one up nor frees one: a chart of a black trace
+ * and a blue one is handed vermillion next, exactly as it would have been had
+ * the black one never been recoloured.
+ * @param taken - The colours the spectra already hold, in any order.
+ * @returns One of `SPECTRUM_COLORS`.
+ */
+export declare function nextSpectrumColor(taken: readonly string[]): string;
+//# sourceMappingURL=spectrumColor.d.ts.map

package/lib/chart/core/spectrumColor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spectrumColor.d.ts","sourceRoot":"","sources":["../../../src/chart/core/spectrumColor.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAE5C,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAOlD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAGhD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAiBlE"}

package/lib/chart/core/spectrumColor.js

@@ -0,0 +1,120 @@
+import { CHART_SERIES_COLORS } from "./chartPalette.js";
+/** The universal set's yellow, which a one-pixel stick cannot be drawn in. */
+const CHART_YELLOW = '#f0e442';
+/** Its neutral dark, which is already the ink the axes are drawn in. */
+const CHART_NEUTRAL = '#4d4d4d';
+/**
+ * The two of the eight a line has to do without.
+ *
+ * Above the palette it filters rather than below it with the other helpers:
+ * the list is built as the module is evaluated, so anything it reads has to
+ * exist by then.
+ */
+const NOT_FOR_A_LINE = new Set([CHART_YELLOW, CHART_NEUTRAL]);
+/**
+ * The colours spectra are told apart by, in two tiers.
+ *
+ * A viewer holds a handful of spectra at a time — a measurement, a reference,
+ * a predicted distribution — so the palette is short and every hue in it is
+ * distinguishable at the width of a one-pixel stick, which is all a centroid
+ * ever is. It is deliberately not a generated scale: named colours stay the same
+ * from one session to the next, and a chemist who calls the blue one "the blank"
+ * is still right tomorrow.
+ *
+ * A colour is the only thing telling one trace from another once they overlap,
+ * so a palette that fails for the one man in twelve with a colour vision
+ * deficiency fails at the only job it has. The matplotlib hues this used to hold
+ * put a red beside a green — the very pair a deuteranope reads as one colour,
+ * and the pair a blank and its sample are most often drawn in.
+ *
+ * That is why there are two tiers rather than one long list. Okabe and Ito's set
+ * is short because it holds only colours that survive **every** deficiency at
+ * once, including the rarer ones where two channels are affected; the Color
+ * Universal Design accent set that the same work grew into is longer because it
+ * asks only that a reader missing **one** channel can tell its members apart.
+ * Both are true, and which one is wanted depends on who is reading the chart, so
+ * the short set is what a chart hands out by itself and the longer one is what a
+ * reader may reach for. Nothing picks a colour out of the second tier on anyone's
+ * behalf.
+ *
+ * Every viewer offers both tiers and none of them keeps a set of its own: two
+ * charts on one page have to name a spectrum the same way, and a palette copied
+ * into a second package is a palette that drifts from the first.
+ */
+/**
+ * The colours a spectrum is drawn in, in the order they are handed out.
+ *
+ * Okabe and Ito's universal set exactly as {@link CHART_SERIES_COLORS} holds
+ * it, less the two a line cannot use: their yellow, which is faint on a white
+ * plot at the width of a stick, and the neutral dark, which is already the ink
+ * of the axes and the labels. Both are still offered, one tier down.
+ *
+ * Derived rather than written out, because a palette copied into a second
+ * place is a palette that drifts from the first: a scatter plot and a spectrum
+ * on the same page have to call the same blue the same blue.
+ *
+ * Blue and vermillion come first because the commonest use is two spectra
+ * compared — the pair that reads most clearly, and the pair a mirror plot
+ * expects.
+ */
+export const SPECTRUM_COLORS = CHART_SERIES_COLORS.filter((color) => !NOT_FOR_A_LINE.has(color));
+export const EXTRA_SPECTRUM_COLORS = [
+    '#000000', // black
+    CHART_YELLOW,
+    '#ff8082', // pink
+    '#990099', // purple
+    '#804000', // brown
+    '#7f878f', // grey
+];
+/**
+ * Both tiers in one list, the handed-out six first.
+ *
+ * What a picker shows. The order is the tiers in order and never sorted by hue:
+ * a reader who has learnt that the first chip is the blue their blank is drawn
+ * in must find it in the same place in every viewer, and the row a colour sits
+ * in is itself the answer to "will this survive whoever reads the figure".
+ */
+export const ALL_SPECTRUM_COLORS = [
+    ...SPECTRUM_COLORS,
+    ...EXTRA_SPECTRUM_COLORS,
+];
+/**
+ * The colour to give the next spectrum, given the ones already in use.
+ *
+ * The lowest unused hue, never one derived from how many spectra there are:
+ * dropping the second of three and loading another would otherwise hand out a
+ * colour already on the chart, and two spectra of the same blue is the one
+ * mistake a colour is there to prevent.
+ *
+ * Once every hue is taken it falls to the least-used one, lowest first — the
+ * same rule, since an unused hue is a hue used no times. It never reaches into
+ * the second tier to avoid a repeat: a colour only that reader's eyes can place
+ * is a choice made for them, and a seventh blue they can read beats a brown they
+ * cannot.
+ *
+ * A spectrum a reader has drawn in a second-tier colour counts as holding none
+ * of the six, so it neither uses one up nor frees one: a chart of a black trace
+ * and a blue one is handed vermillion next, exactly as it would have been had
+ * the black one never been recoloured.
+ * @param taken - The colours the spectra already hold, in any order.
+ * @returns One of `SPECTRUM_COLORS`.
+ */
+export function nextSpectrumColor(taken) {
+    const counts = new Array(SPECTRUM_COLORS.length).fill(0);
+    for (const color of taken) {
+        const index = SPECTRUM_COLORS.indexOf(color);
+        if (index !== -1)
+            counts[index] = counts[index] + 1;
+    }
+    let best = SPECTRUM_COLORS[0];
+    let bestCount = counts[0];
+    for (let index = 1; index < counts.length && bestCount > 0; index++) {
+        const count = counts[index];
+        if (count < bestCount) {
+            best = SPECTRUM_COLORS[index];
+            bestCount = count;
+        }
+    }
+    return best;
+}
+//# sourceMappingURL=spectrumColor.js.map

package/lib/chart/core/spectrumColor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spectrumColor.js","sourceRoot":"","sources":["../../../src/chart/core/spectrumColor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,8EAA8E;AAC9E,MAAM,YAAY,GAAG,SAAS,CAAC;AAE/B,wEAAwE;AACxE,MAAM,aAAa,GAAG,SAAS,CAAC;AAEhC;;;;;;GAMG;AACH,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,eAAe,GAAsB,mBAAmB,CAAC,MAAM,CAC1E,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,CACtC,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAsB;IACtD,SAAS,EAAE,QAAQ;IACnB,YAAY;IACZ,SAAS,EAAE,OAAO;IAClB,SAAS,EAAE,SAAS;IACpB,SAAS,EAAE,QAAQ;IACnB,SAAS,EAAE,OAAO;CACnB,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAsB;IACpD,GAAG,eAAe;IAClB,GAAG,qBAAqB;CACzB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAwB;IACxD,MAAM,MAAM,GAAG,IAAI,KAAK,CAAS,eAAe,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACjE,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE,CAAC;QAC1B,MAAM,KAAK,GAAG,eAAe,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAC7C,IAAI,KAAK,KAAK,CAAC,CAAC;YAAE,MAAM,CAAC,KAAK,CAAC,GAAI,MAAM,CAAC,KAAK,CAAY,GAAG,CAAC,CAAC;IAClE,CAAC;IAED,IAAI,IAAI,GAAG,eAAe,CAAC,CAAC,CAAW,CAAC;IACxC,IAAI,SAAS,GAAG,MAAM,CAAC,CAAC,CAAW,CAAC;IACpC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,IAAI,SAAS,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;QACpE,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAW,CAAC;QACtC,IAAI,KAAK,GAAG,SAAS,EAAE,CAAC;YACtB,IAAI,GAAG,eAAe,CAAC,KAAK,CAAW,CAAC;YACxC,SAAS,GAAG,KAAK,CAAC;QACpB,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/lib/chart/core/stackCapacity.d.ts

@@ -0,0 +1,136 @@
+/**
+ * How many charts a column of a given height can stack, and how tall each stands.
+ *
+ * A viewer that draws one pane per selected spectrum has to answer a question
+ * the stack itself never asks. A reader who ticks a dozen spectra has not asked
+ * for twelve panes of fifty pixels, and a stack handed them draws twelve stubs
+ * with a full set of axes over each — the failure `ChartStack.tsx`'s header
+ * describes, arrived at from above instead of through a splitter. So the number
+ * of panes is settled from the height actually available, against the stack's
+ * own floors rather than a number somebody hoped for, and whatever a reader
+ * selects past that number is overlaid together into the last pane rather than
+ * dropped, which is the one outcome a reader cannot see happening.
+ *
+ * All of it is arithmetic over `chartStackLevel.tsx`'s floors and
+ * `chartGeometry.ts`'s margins; nothing here renders, measures or reads a
+ * spectrum.
+ */
+/**
+ * The shortest a pane that is *not* at the foot of the stack may stand, in
+ * pixels.
+ *
+ * Ninety, and ninety exactly, because it is not a judgement about how short a
+ * chart may be: `chartStackLevel.tsx` hands `SplitPane` a `closeThreshold` of 90
+ * at every non-foot split, and a split measuring under that closes its pane
+ * outright — before a splitter has ever been touched, so a stack built on a
+ * floor of 80 would come up with panes already shut and no gesture that made
+ * them so. The threshold is applied as `>=`, which is why standing exactly on it
+ * is allowed. That constant is module-private over there, so its value is
+ * restated here and the two have to move together.
+ *
+ * A caller must state this as each pane's own `minimumHeight`. Left unsaid,
+ * `paneHeight` clamps the pane up to the 120 pixels it defaults to, and five
+ * panes would then demand 688 pixels where 538 draws them.
+ */
+export declare const STACKED_MINIMUM = 90;
+/**
+ * What the pane at the foot pays for its axis beyond what every pane pays, in
+ * pixels.
+ *
+ * Only the foot of a stack writes the tick row and the axis title under its
+ * plot, and that is `MARGIN.bottom` less the `SHARED_AXIS_MARGIN` a pane keeps
+ * even when it writes no axis — 26 of them, not 34. The *difference* is what
+ * matters and the whole bottom margin is not it: a stacked pane still leaves a
+ * little room under its trace, and charging the foot for all 34 draws its plot
+ * eight pixels taller than the others, so a peak of one intensity comes out
+ * taller at the bottom of the stack than at the top. Every other side of the margin
+ * is paid alike by every pane, the room kept above the plot for the tallest
+ * peak's label as much as the gutter the value labels are written in, so it
+ * cancels out of the difference between two panes and does not appear here.
+ * This one asymmetry is the whole of why an equal split of the *boxes* is not an
+ * equal split of the *plots*.
+ */
+export declare const FOOT_FURNITURE: number;
+/**
+ * The shortest the pane at the foot may stand, in pixels.
+ *
+ * The ordinary floor plus the tick row and axis title only it writes, so that
+ * the plot left inside it is the same plot `STACKED_MINIMUM` leaves inside a
+ * pane above it. Deriving it rather than picking 116 is what makes the tightest
+ * stack land exactly on both floors at once: at a height of
+ * `FOOT_MINIMUM + (n - 1) * STACKED_MINIMUM`, `stackShares` gives every pane
+ * above the foot exactly `STACKED_MINIMUM` and the foot exactly this.
+ */
+export declare const FOOT_MINIMUM: number;
+/**
+ * How much room the splitter between two panes takes, in pixels.
+ *
+ * `react-science` draws a vertical splitter as a ten-pixel bar, and there is one
+ * between each *pair* of panes rather than one per pane — five of them under six
+ * panes. Small enough to be forgotten and large enough that forgetting it costs
+ * a pane: the fifty it comes to across a full stack is more than half a stacked
+ * minimum.
+ */
+export declare const SPLITTER = 10;
+/**
+ * The most panes worth stacking at all, however tall the column.
+ *
+ * Six, and the height is not what settles it. A 1080-pixel screen with the side
+ * panels open leaves the stack something near 900 pixels; six panes take 50 of
+ * those in splitters and share the rest, which is a box of 133 pixels each and a
+ * plot inside it of barely a hundred — about the height of the label stack a
+ * mass spectrum draws over its tallest sticks, so a seventh pane makes the
+ * labels taller than the trace they belong to. And the reader stacked the panes
+ * in order to compare them: past six the first and the last are most of a page
+ * apart, and an eye travelling that far is no longer comparing anything.
+ * Whatever is selected beyond this is overlaid into the last pane, where traces
+ * drawn over one another are compared the way they always were.
+ */
+export declare const STACK_LIMIT = 6;
+/**
+ * How many panes a column of a given height can hold and still draw spectra.
+ *
+ * The arithmetic is the stack as it will actually be built: one pane at the foot
+ * carrying the horizontal axis, every other pane at the stacked floor, and a
+ * splitter between each pair. Nothing here rounds in the caller's favour — a
+ * height one pixel short of the fourth pane holds three.
+ * @param height - The whole column the stack fills, in pixels, with the
+ * splitters counted in: it is the box `ChartStack` is handed, not the room its
+ * panes are left with.
+ * @returns At least one, because a lone pane squeezed short is still the
+ * measurement and the stack draws it rather than nothing — that is why the foot
+ * pane is given no close threshold — and never more than `STACK_LIMIT`.
+ */
+export declare function stackCapacity(height: number): number;
+/**
+ * How tall each pane of the stack stands, top to bottom.
+ *
+ * The split equalises the **plot** rather than the box. An equal share of the
+ * box hands the foot pane 34 pixels of tick row and axis title that the panes
+ * above it do not draw, so its trace comes out visibly shorter than theirs while
+ * every box measures the same — the one thing a reader comparing two spectra
+ * side by side must not be shown. So `FOOT_FURNITURE` is taken off the top, what
+ * is left is divided evenly, and the foot is given its share back with the
+ * furniture on it.
+ *
+ * The division is floored, so the panes above the foot are whole pixels and the
+ * remainder — never more than `count - 1` of them — lands on the foot, which is
+ * the tallest pane and the one where two pixels are least visible. That keeps
+ * the sum exact, and it is also why the foot's share is *at least*
+ * `FOOT_FURNITURE` above a stacked one rather than exactly it.
+ * @param height - The room the panes themselves share, in pixels. A caller
+ * holding the whole column subtracts the splitters first — `height -
+ * (count - 1) * SPLITTER` — because `SplitPane` takes those out of the panes,
+ * not out of the column.
+ * @param count - How many panes to stack, normally whatever `stackCapacity`
+ * answered.
+ * @returns One height per pane, summing exactly to `height`, each at or above
+ * its own floor. The two cannot both hold for a height short of what `count`
+ * panes need, and there the floors win and the sum overshoots: a pane under its
+ * floor is the stub with a full set of axes over it, which is the worse of the
+ * two pictures. A lone pane is the exception and takes the whole height floor
+ * and all, since there is nothing to redistribute to and nothing to compare it
+ * against.
+ */
+export declare function stackShares(height: number, count: number): readonly number[];
+//# sourceMappingURL=stackCapacity.d.ts.map

package/lib/chart/core/stackCapacity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stackCapacity.d.ts","sourceRoot":"","sources":["../../../src/chart/core/stackCapacity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,eAAe,KAAK,CAAC;AAElC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc,QAAqC,CAAC;AAEjE;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,QAAmC,CAAC;AAE7D;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,KAAK,CAAC;AAE3B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW,IAAI,CAAC;AAE7B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAIpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAc5E"}

package/lib/chart/core/stackCapacity.js

@@ -0,0 +1,153 @@
+/**
+ * How many charts a column of a given height can stack, and how tall each stands.
+ *
+ * A viewer that draws one pane per selected spectrum has to answer a question
+ * the stack itself never asks. A reader who ticks a dozen spectra has not asked
+ * for twelve panes of fifty pixels, and a stack handed them draws twelve stubs
+ * with a full set of axes over each — the failure `ChartStack.tsx`'s header
+ * describes, arrived at from above instead of through a splitter. So the number
+ * of panes is settled from the height actually available, against the stack's
+ * own floors rather than a number somebody hoped for, and whatever a reader
+ * selects past that number is overlaid together into the last pane rather than
+ * dropped, which is the one outcome a reader cannot see happening.
+ *
+ * All of it is arithmetic over `chartStackLevel.tsx`'s floors and
+ * `chartGeometry.ts`'s margins; nothing here renders, measures or reads a
+ * spectrum.
+ */
+import { MARGIN, SHARED_AXIS_MARGIN } from "./chartGeometry.js";
+/**
+ * The shortest a pane that is *not* at the foot of the stack may stand, in
+ * pixels.
+ *
+ * Ninety, and ninety exactly, because it is not a judgement about how short a
+ * chart may be: `chartStackLevel.tsx` hands `SplitPane` a `closeThreshold` of 90
+ * at every non-foot split, and a split measuring under that closes its pane
+ * outright — before a splitter has ever been touched, so a stack built on a
+ * floor of 80 would come up with panes already shut and no gesture that made
+ * them so. The threshold is applied as `>=`, which is why standing exactly on it
+ * is allowed. That constant is module-private over there, so its value is
+ * restated here and the two have to move together.
+ *
+ * A caller must state this as each pane's own `minimumHeight`. Left unsaid,
+ * `paneHeight` clamps the pane up to the 120 pixels it defaults to, and five
+ * panes would then demand 688 pixels where 538 draws them.
+ */
+export const STACKED_MINIMUM = 90;
+/**
+ * What the pane at the foot pays for its axis beyond what every pane pays, in
+ * pixels.
+ *
+ * Only the foot of a stack writes the tick row and the axis title under its
+ * plot, and that is `MARGIN.bottom` less the `SHARED_AXIS_MARGIN` a pane keeps
+ * even when it writes no axis — 26 of them, not 34. The *difference* is what
+ * matters and the whole bottom margin is not it: a stacked pane still leaves a
+ * little room under its trace, and charging the foot for all 34 draws its plot
+ * eight pixels taller than the others, so a peak of one intensity comes out
+ * taller at the bottom of the stack than at the top. Every other side of the margin
+ * is paid alike by every pane, the room kept above the plot for the tallest
+ * peak's label as much as the gutter the value labels are written in, so it
+ * cancels out of the difference between two panes and does not appear here.
+ * This one asymmetry is the whole of why an equal split of the *boxes* is not an
+ * equal split of the *plots*.
+ */
+export const FOOT_FURNITURE = MARGIN.bottom - SHARED_AXIS_MARGIN;
+/**
+ * The shortest the pane at the foot may stand, in pixels.
+ *
+ * The ordinary floor plus the tick row and axis title only it writes, so that
+ * the plot left inside it is the same plot `STACKED_MINIMUM` leaves inside a
+ * pane above it. Deriving it rather than picking 116 is what makes the tightest
+ * stack land exactly on both floors at once: at a height of
+ * `FOOT_MINIMUM + (n - 1) * STACKED_MINIMUM`, `stackShares` gives every pane
+ * above the foot exactly `STACKED_MINIMUM` and the foot exactly this.
+ */
+export const FOOT_MINIMUM = STACKED_MINIMUM + FOOT_FURNITURE;
+/**
+ * How much room the splitter between two panes takes, in pixels.
+ *
+ * `react-science` draws a vertical splitter as a ten-pixel bar, and there is one
+ * between each *pair* of panes rather than one per pane — five of them under six
+ * panes. Small enough to be forgotten and large enough that forgetting it costs
+ * a pane: the fifty it comes to across a full stack is more than half a stacked
+ * minimum.
+ */
+export const SPLITTER = 10;
+/**
+ * The most panes worth stacking at all, however tall the column.
+ *
+ * Six, and the height is not what settles it. A 1080-pixel screen with the side
+ * panels open leaves the stack something near 900 pixels; six panes take 50 of
+ * those in splitters and share the rest, which is a box of 133 pixels each and a
+ * plot inside it of barely a hundred — about the height of the label stack a
+ * mass spectrum draws over its tallest sticks, so a seventh pane makes the
+ * labels taller than the trace they belong to. And the reader stacked the panes
+ * in order to compare them: past six the first and the last are most of a page
+ * apart, and an eye travelling that far is no longer comparing anything.
+ * Whatever is selected beyond this is overlaid into the last pane, where traces
+ * drawn over one another are compared the way they always were.
+ */
+export const STACK_LIMIT = 6;
+/**
+ * How many panes a column of a given height can hold and still draw spectra.
+ *
+ * The arithmetic is the stack as it will actually be built: one pane at the foot
+ * carrying the horizontal axis, every other pane at the stacked floor, and a
+ * splitter between each pair. Nothing here rounds in the caller's favour — a
+ * height one pixel short of the fourth pane holds three.
+ * @param height - The whole column the stack fills, in pixels, with the
+ * splitters counted in: it is the box `ChartStack` is handed, not the room its
+ * panes are left with.
+ * @returns At least one, because a lone pane squeezed short is still the
+ * measurement and the stack draws it rather than nothing — that is why the foot
+ * pane is given no close threshold — and never more than `STACK_LIMIT`.
+ */
+export function stackCapacity(height) {
+    const beyondTheFoot = height - FOOT_MINIMUM;
+    const fits = 1 + Math.floor(beyondTheFoot / (STACKED_MINIMUM + SPLITTER));
+    return Math.min(STACK_LIMIT, Math.max(1, fits));
+}
+/**
+ * How tall each pane of the stack stands, top to bottom.
+ *
+ * The split equalises the **plot** rather than the box. An equal share of the
+ * box hands the foot pane 34 pixels of tick row and axis title that the panes
+ * above it do not draw, so its trace comes out visibly shorter than theirs while
+ * every box measures the same — the one thing a reader comparing two spectra
+ * side by side must not be shown. So `FOOT_FURNITURE` is taken off the top, what
+ * is left is divided evenly, and the foot is given its share back with the
+ * furniture on it.
+ *
+ * The division is floored, so the panes above the foot are whole pixels and the
+ * remainder — never more than `count - 1` of them — lands on the foot, which is
+ * the tallest pane and the one where two pixels are least visible. That keeps
+ * the sum exact, and it is also why the foot's share is *at least*
+ * `FOOT_FURNITURE` above a stacked one rather than exactly it.
+ * @param height - The room the panes themselves share, in pixels. A caller
+ * holding the whole column subtracts the splitters first — `height -
+ * (count - 1) * SPLITTER` — because `SplitPane` takes those out of the panes,
+ * not out of the column.
+ * @param count - How many panes to stack, normally whatever `stackCapacity`
+ * answered.
+ * @returns One height per pane, summing exactly to `height`, each at or above
+ * its own floor. The two cannot both hold for a height short of what `count`
+ * panes need, and there the floors win and the sum overshoots: a pane under its
+ * floor is the stub with a full set of axes over it, which is the worse of the
+ * two pictures. A lone pane is the exception and takes the whole height floor
+ * and all, since there is nothing to redistribute to and nothing to compare it
+ * against.
+ */
+export function stackShares(height, count) {
+    if (!Number.isInteger(count) || count < 1)
+        return [];
+    if (count === 1)
+        return [height];
+    const stacked = Math.max(STACKED_MINIMUM, Math.floor((height - FOOT_FURNITURE) / count));
+    const shares = new Array(count);
+    for (let index = 0; index < count - 1; index++) {
+        shares[index] = stacked;
+    }
+    shares[count - 1] = Math.max(FOOT_MINIMUM, height - stacked * (count - 1));
+    return shares;
+}
+//# sourceMappingURL=stackCapacity.js.map

package/lib/chart/core/stackCapacity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stackCapacity.js","sourceRoot":"","sources":["../../../src/chart/core/stackCapacity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAEhE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,CAAC;AAElC;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,GAAG,kBAAkB,CAAC;AAEjE;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,eAAe,GAAG,cAAc,CAAC;AAE7D;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,EAAE,CAAC;AAE3B;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC;AAE7B;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,aAAa,CAAC,MAAc;IAC1C,MAAM,aAAa,GAAG,MAAM,GAAG,YAAY,CAAC;IAC5C,MAAM,IAAI,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,GAAG,CAAC,eAAe,GAAG,QAAQ,CAAC,CAAC,CAAC;IAC1E,OAAO,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;AAClD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,WAAW,CAAC,MAAc,EAAE,KAAa;IACvD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC;QAAE,OAAO,EAAE,CAAC;IACrD,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAEjC,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CACtB,eAAe,EACf,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,cAAc,CAAC,GAAG,KAAK,CAAC,CAC9C,CAAC;IACF,MAAM,MAAM,GAAG,IAAI,KAAK,CAAS,KAAK,CAAC,CAAC;IACxC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;QAC/C,MAAM,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC;IAC1B,CAAC;IACD,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;IAC3E,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/lib/chart/core/svgPoint.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Turning a pointer on the screen into a point on the chart.
+ *
+ * Asked by everything that reads a gesture — the crosshair, the box zoom, the
+ * click that pins a label — so it is answered once, here, and all of them place
+ * the pointer in the same place.
+ *
+ * The SVG's own screen matrix is the only correct answer once the chart carries
+ * a `viewBox`: the element then draws in user units of its own, and a pointer
+ * 300 CSS pixels from the left edge of an 800-pixel-wide chart showing 600 user
+ * units is at 225 of them, not at 300. The matrix carries that scaling, the
+ * device pixel ratio and any transform an ancestor applies, all at once, so
+ * nothing downstream has to know that any of them happened.
+ */
+/** A point on the chart, in the user units its `viewBox` is written in. */
+export interface ChartPoint {
+    /** Distance from the left edge of the SVG. */
+    x: number;
+    /** Distance from its top edge. */
+    y: number;
+}
+/** The little of an SVG matrix a pointer position is worked out from. */
+export interface ScreenMatrix {
+    /** Horizontal scaling. */
+    a: number;
+    /** Vertical shear. */
+    b: number;
+    /** Horizontal shear. */
+    c: number;
+    /** Vertical scaling. */
+    d: number;
+    /** Horizontal translation. */
+    e: number;
+    /** Vertical translation. */
+    f: number;
+    /** The matrix that undoes this one. */
+    inverse: () => ScreenMatrix;
+}
+/** The little of an SVG element a pointer position is asked of. */
+export interface PointerSurface {
+    /** How the SVG's user units are laid over the screen. */
+    getScreenCTM: () => ScreenMatrix | null;
+}
+/**
+ * Where a pointer is, in the user units the SVG draws in.
+ *
+ * The matrix maps user units onto the screen, so it is inverted to go the other
+ * way. It is applied here rather than through a `DOMPoint` so that the
+ * arithmetic can be read — and tested — without a browser standing by.
+ *
+ * A surface that is not laid out has no matrix to give: an SVG inside a folded
+ * panel, or one whose `viewBox` has collapsed to nothing, answers `null` rather
+ * than a matrix of zeros, and the caller is then told there is no position
+ * instead of being handed an infinity that lands every gesture at the same
+ * impossible place.
+ * @param surface - The SVG, `null` before it is on screen.
+ * @param clientX - Where the pointer is on the screen, horizontally.
+ * @param clientY - Where it is vertically.
+ * @returns The point, `null` when the surface cannot place it.
+ */
+export declare function svgPointAt(surface: PointerSurface | null, clientX: number, clientY: number): ChartPoint | null;
+//# sourceMappingURL=svgPoint.d.ts.map

package/lib/chart/core/svgPoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svgPoint.d.ts","sourceRoot":"","sources":["../../../src/chart/core/svgPoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,2EAA2E;AAC3E,MAAM,WAAW,UAAU;IACzB,8CAA8C;IAC9C,CAAC,EAAE,MAAM,CAAC;IACV,kCAAkC;IAClC,CAAC,EAAE,MAAM,CAAC;CACX;AAED,yEAAyE;AACzE,MAAM,WAAW,YAAY;IAC3B,0BAA0B;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,sBAAsB;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,wBAAwB;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,wBAAwB;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,8BAA8B;IAC9B,CAAC,EAAE,MAAM,CAAC;IACV,4BAA4B;IAC5B,CAAC,EAAE,MAAM,CAAC;IACV,uCAAuC;IACvC,OAAO,EAAE,MAAM,YAAY,CAAC;CAC7B;AAED,mEAAmE;AACnE,MAAM,WAAW,cAAc;IAC7B,yDAAyD;IACzD,YAAY,EAAE,MAAM,YAAY,GAAG,IAAI,CAAC;CACzC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,cAAc,GAAG,IAAI,EAC9B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,UAAU,GAAG,IAAI,CAQnB"}