react-cheminfo 0.28.0 → 0.29.0

package/lib/chart/core/viewTransform.js

@@ -0,0 +1,188 @@
+/** Closest and furthest the canvas will go. */
+export const MINIMUM_ZOOM = 0.25;
+export const MAXIMUM_ZOOM = 8;
+/**
+ * Biggest a drawing unit is ever drawn at, in pixels, unless a caller says
+ * otherwise.
+ *
+ * Chosen against the glycan canvas, where a symbol is 34 units across and a
+ * bond 60 long, so a drawing at this scale reads about the size it does in a
+ * paper — which is as big as it is worth drawing. Without the cap a
+ * disaccharide on a wide screen is blown up until three residues fill a metre
+ * of pixels. A surface with its own idea of how big is big enough passes its
+ * own maximum instead.
+ */
+export const MAXIMUM_CONTENT_SCALE = 1.5;
+/** The base view, seen as it comes: no zoom, no pan. */
+export const INITIAL_VIEW = { zoom: 1, panX: 0, panY: 0 };
+/**
+ * What the canvas shows before it is zoomed or panned.
+ *
+ * A drawing too big for the canvas is fitted to it, as anything drawn to be
+ * looked at whole must be. A drawing smaller than that is *not* stretched to
+ * fill it: it is drawn at its own size, up to `maximumScale`, in the middle of
+ * a window opened around it — so a disaccharide reads like a disaccharide
+ * however wide the screen it is on, and the empty canvas around it is still
+ * canvas, there to be clicked and drawn on.
+ * @param content - Size of the whole drawing, in canvas units.
+ * @param content.width - How wide the drawing is.
+ * @param content.height - How tall the drawing is.
+ * @param viewport - Size of the canvas on screen, in pixels.
+ * @param viewport.width - How wide the canvas is.
+ * @param viewport.height - How tall the canvas is.
+ * @param maximumScale - Biggest a canvas unit may be drawn, in pixels.
+ * @returns The rectangle of the drawing seen at zoom `1`.
+ */
+export function baseViewBox(content, viewport, maximumScale = MAXIMUM_CONTENT_SCALE) {
+    // Before the canvas has been measured there is nothing to fit the drawing
+    // to; showing it whole is what the `viewBox` does on its own anyway.
+    if (content.width <= 0 ||
+        content.height <= 0 ||
+        viewport.width <= 0 ||
+        viewport.height <= 0) {
+        return { x: 0, y: 0, width: content.width, height: content.height };
+    }
+    const fitted = Math.min(viewport.width / content.width, viewport.height / content.height);
+    const scale = Math.min(fitted, maximumScale);
+    const width = viewport.width / scale;
+    const height = viewport.height / scale;
+    return {
+        x: (content.width - width) / 2,
+        y: (content.height - height) / 2,
+        width,
+        height,
+    };
+}
+/**
+ * The magnification a window factor asks for.
+ *
+ * There are two ways to say "zoom" and this package uses both, so the
+ * conversion is named rather than written as a stray reciprocal. A chart zooms
+ * by resizing the **window** it shows — `chartWheelFactor` returns that, and a
+ * factor above one means a wider window and therefore less magnification. A
+ * drawing surface zooms by scaling the picture, so `zoomAbout` takes a
+ * **magnification**, where above one means larger.
+ *
+ * Feeding one to the other reverses the wheel: the gesture still works, it
+ * simply does the opposite of what the hand meant, which is the kind of defect
+ * that survives review because nothing throws and the picture still moves.
+ * @param windowFactor - How much the window is being multiplied by.
+ * @returns The magnification that corresponds to it.
+ */
+export function magnificationOf(windowFactor) {
+    if (!Number.isFinite(windowFactor) || windowFactor === 0)
+        return 1;
+    return 1 / windowFactor;
+}
+/**
+ * Hold a zoom inside what the surface allows.
+ * @param zoom - The wanted zoom.
+ * @param bounds - How far in and out this surface goes.
+ * @returns The zoom it will actually use.
+ */
+export function clampZoom(zoom, bounds = {}) {
+    const { minimum = MINIMUM_ZOOM, maximum = MAXIMUM_ZOOM } = bounds;
+    // A zoom that is not a number at all is a lost view rather than a small one,
+    // so it comes back to the base rather than to the floor — held inside the
+    // bounds all the same, since a surface whose floor is the fit has no base
+    // below it.
+    const wanted = Number.isFinite(zoom) ? zoom : 1;
+    return Math.min(maximum, Math.max(minimum, wanted));
+}
+/**
+ * Zoom while keeping one point of the drawing under the pointer.
+ *
+ * Without the anchor the drawing would drift away from the cursor as it grows,
+ * which is what makes a wheel zoom feel wrong.
+ * @param view - Where the canvas is now.
+ * @param base - What the canvas shows at zoom `1`.
+ * @param factor - How much to multiply the zoom by.
+ * @param anchor - The surface point to keep still, usually the pointer.
+ * @param anchor.x - Its horizontal position, in drawing units.
+ * @param anchor.y - Its vertical position, in drawing units.
+ * @param bounds - How far in and out this surface goes.
+ * @returns Where the canvas goes.
+ */
+export function zoomAbout(view, base, factor, anchor, bounds = {}) {
+    const zoom = clampZoom(view.zoom * factor, bounds);
+    if (zoom === view.zoom)
+        return view;
+    const beforeWidth = base.width / view.zoom;
+    const beforeHeight = base.height / view.zoom;
+    const afterWidth = base.width / zoom;
+    const afterHeight = base.height / zoom;
+    // The pan is measured from the base view, so the anchor is read from there
+    // too: a window written that way keeps its place over the drawing when the
+    // canvas is resized and the base view moves under it.
+    const anchorX = anchor.x - base.x;
+    const anchorY = anchor.y - base.y;
+    const fractionX = beforeWidth === 0 ? 0 : (anchorX - view.panX) / beforeWidth;
+    const fractionY = beforeHeight === 0 ? 0 : (anchorY - view.panY) / beforeHeight;
+    return {
+        zoom,
+        panX: anchorX - fractionX * afterWidth,
+        panY: anchorY - fractionY * afterHeight,
+    };
+}
+/**
+ * Slide the window, in canvas units.
+ * @param view - Where the canvas is now.
+ * @param deltaX - How far to move it horizontally.
+ * @param deltaY - How far to move it vertically.
+ * @returns Where the canvas goes.
+ */
+export function panBy(view, deltaX, deltaY) {
+    return {
+        zoom: view.zoom,
+        panX: view.panX - deltaX,
+        panY: view.panY - deltaY,
+    };
+}
+/**
+ * Set the zoom about the middle of what is on screen, which is what the
+ * toolbar buttons want — they have no pointer to zoom around.
+ * @param view - Where the canvas is now.
+ * @param base - What the canvas shows at zoom `1`.
+ * @param zoom - The wanted zoom.
+ * @param bounds - How far in and out this surface goes.
+ * @returns Where the canvas goes.
+ */
+export function zoomToAboutCentre(view, base, zoom, bounds = {}) {
+    const centre = {
+        x: base.x + view.panX + base.width / view.zoom / 2,
+        y: base.y + view.panY + base.height / view.zoom / 2,
+    };
+    return zoomAbout(view, base, clampZoom(zoom, bounds) / view.zoom, centre, bounds);
+}
+/**
+ * The rectangle of the drawing the canvas is showing.
+ * @param view - Where the canvas is.
+ * @param base - What the canvas shows at zoom `1`.
+ * @returns The rectangle.
+ */
+export function viewBoxOf(view, base) {
+    return {
+        x: base.x + view.panX,
+        y: base.y + view.panY,
+        width: base.width / view.zoom,
+        height: base.height / view.zoom,
+    };
+}
+/**
+ * The rectangle, written the way the `viewBox` attribute wants it.
+ * @param box - The rectangle.
+ * @returns The attribute.
+ */
+export function viewBoxAttribute(box) {
+    return `${round(box.x)} ${round(box.y)} ${round(box.width)} ${round(box.height)}`;
+}
+/**
+ * A coordinate, short enough not to bloat an attribute rewritten on every
+ * frame of a drag.
+ * @param value - The coordinate.
+ * @returns It, to two decimals.
+ */
+function round(value) {
+    return Math.round(value * 100) / 100;
+}
+//# sourceMappingURL=viewTransform.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"viewTransform.js","sourceRoot":"","sources":["../../../src/chart/core/viewTransform.ts"],"names":[],"mappings":"AA+BA,+CAA+C;AAC/C,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,CAAC;AACjC,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,CAAC;AAEzC,wDAAwD;AACxD,MAAM,CAAC,MAAM,YAAY,GAAc,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;AAErE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,WAAW,CACzB,OAA0C,EAC1C,QAA2C,EAC3C,YAAY,GAAG,qBAAqB;IAEpC,0EAA0E;IAC1E,qEAAqE;IACrE,IACE,OAAO,CAAC,KAAK,IAAI,CAAC;QAClB,OAAO,CAAC,MAAM,IAAI,CAAC;QACnB,QAAQ,CAAC,KAAK,IAAI,CAAC;QACnB,QAAQ,CAAC,MAAM,IAAI,CAAC,EACpB,CAAC;QACD,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;IACtE,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CACrB,QAAQ,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,EAC9B,QAAQ,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CACjC,CAAC;IACF,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC7C,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,GAAG,KAAK,CAAC;IACrC,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,GAAG,KAAK,CAAC;IAEvC,OAAO;QACL,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC;QAC9B,CAAC,EAAE,CAAC,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC;QAChC,KAAK;QACL,MAAM;KACP,CAAC;AACJ,CAAC;AAyBD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,eAAe,CAAC,YAAoB;IAClD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,YAAY,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IACnE,OAAO,CAAC,GAAG,YAAY,CAAC;AAC1B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAC,IAAY,EAAE,SAAqB,EAAE;IAC7D,MAAM,EAAE,OAAO,GAAG,YAAY,EAAE,OAAO,GAAG,YAAY,EAAE,GAAG,MAAM,CAAC;IAClE,6EAA6E;IAC7E,0EAA0E;IAC1E,0EAA0E;IAC1E,YAAY;IACZ,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAChD,OAAO,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,SAAS,CACvB,IAAe,EACf,IAAa,EACb,MAAc,EACd,MAAgC,EAChC,SAAqB,EAAE;IAEvB,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,IAAI,GAAG,MAAM,EAAE,MAAM,CAAC,CAAC;IACnD,IAAI,IAAI,KAAK,IAAI,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IAEpC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC;IAC3C,MAAM,YAAY,GAAG,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC;IAC7C,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACrC,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;IAEvC,2EAA2E;IAC3E,2EAA2E;IAC3E,sDAAsD;IACtD,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IAClC,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IAElC,MAAM,SAAS,GAAG,WAAW,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC;IAC9E,MAAM,SAAS,GACb,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,YAAY,CAAC;IAEhE,OAAO;QACL,IAAI;QACJ,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,UAAU;QACtC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,WAAW;KACxC,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,KAAK,CACnB,IAAe,EACf,MAAc,EACd,MAAc;IAEd,OAAO;QACL,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,IAAI,EAAE,IAAI,CAAC,IAAI,GAAG,MAAM;QACxB,IAAI,EAAE,IAAI,CAAC,IAAI,GAAG,MAAM;KACzB,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAC/B,IAAe,EACf,IAAa,EACb,IAAY,EACZ,SAAqB,EAAE;IAEvB,MAAM,MAAM,GAAG;QACb,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,GAAG,CAAC;QAClD,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,GAAG,CAAC;KACpD,CAAC;IACF,OAAO,SAAS,CACd,IAAI,EACJ,IAAI,EACJ,SAAS,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,EACnC,MAAM,EACN,MAAM,CACP,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAC,IAAe,EAAE,IAAa;IACtD,OAAO;QACL,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI;QACrB,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI;QACrB,KAAK,EAAE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI;QAC7B,MAAM,EAAE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI;KAChC,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAY;IAC3C,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;AACpF,CAAC;AAED;;;;;GAKG;AACH,SAAS,KAAK,CAAC,KAAa;IAC1B,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;AACvC,CAAC"}

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

@@ -0,0 +1,127 @@
+/**
+ * The window a gesture asks for, where each viewer's own fitting holds the one
+ * the data asks for.
+ *
+ * Nothing here touches React or the DOM: a drag arrives as two corners in the
+ * user units of the SVG, a wheel as a factor, and each leaves as a window — so
+ * what a gesture does to a chart can be read, and tested, without one being on
+ * screen.
+ */
+import type { ChartDomain, ZoomRules } from './chartDomain.ts';
+import type { PlotRect } from './chartGeometry.ts';
+import type { ChartScale } from './chartScale.ts';
+/**
+ * How far the pointer has to travel before a press counts as a gesture rather
+ * than as a click, in user units of the SVG.
+ *
+ * Across the x axis it is what decides whether there is a window at all: below
+ * this the gesture is a click that happened to wobble — which is most clicks
+ * made on a trackpad — and zooming to it would leave a window a fraction of a
+ * data unit wide, from which the only way back is the double click nobody knows
+ * about yet. `chartGestures.ts` asks the same question of the vertical travel
+ * before it calls a release a click, since a drag of one pixel across and three
+ * hundred down went somewhere.
+ */
+export declare const MINIMUM_DRAG = 4;
+/** The two corners of a drag, in the user units of the SVG. */
+export interface DragBox {
+    /** Where the press landed, horizontally. */
+    fromX: number;
+    /** Where it landed vertically. */
+    fromY: number;
+    /** Where the pointer is now, horizontally. */
+    toX: number;
+    /** Where it is vertically. */
+    toY: number;
+}
+/** The drag as it is being made, for the preview rectangle to be drawn from. */
+export interface ZoomSelection extends DragBox {
+    /**
+     * Whether letting go here would take the y axis with it, which is what the
+     * rectangle changes shape to say.
+     */
+    zoomsYAxis: boolean;
+}
+/**
+ * The drag as the preview rectangle needs it.
+ *
+ * The answer the rectangle changes shape on is worked out once, here, rather
+ * than by the rectangle itself — so what the preview promises and what letting
+ * go actually does are the same test rather than two that have to agree.
+ *
+ * A `select` drag is therefore always a band, however far past the baseline it
+ * strays: its answer is two numbers on one axis, so a preview that grew into a
+ * rectangle would promise a height nobody is ever told about.
+ * @param drag - The drag being made, `null` when none is.
+ * @param yScale - The y axis as it is currently zoomed.
+ * @param rules - How the y axis behaves and what a drag means, defaulting to a
+ * stick spectrum read by dragging its horizontal axis.
+ * @returns The selection to draw, `null` when there is no drag.
+ */
+export declare function zoomSelection(drag: DragBox | null, yScale: ChartScale, rules?: ZoomRules): ZoomSelection | null;
+/**
+ * Whether a drag let go here asks for the y axis as well.
+ *
+ * The baseline, not the bottom of the plot: on a mirrored chart zero runs across
+ * the middle, so a drag that dips into the reflected half has crossed it, and on
+ * an ordinary chart the same test means the pointer went below the axis and out
+ * into the margin. One rule, two gestures that both read as "and take the height
+ * with you".
+ *
+ * **Which way "past" points depends on which side of the baseline the data is
+ * on**, which is what `pointsDown` says. Features that stand up out of a
+ * baseline at the foot of the plot — mass sticks, absorbance bands — are passed
+ * by going below it. Percent transmittance hangs down from 100, which sits near
+ * the top of the plot, so there the gesture is a drag released *above* the
+ * baseline; asking the other question would answer yes almost everywhere in the
+ * plot and make every ordinary drag take the value axis with it.
+ * @param pointerY - Where the pointer is, in user units of the SVG.
+ * @param yScale - The y axis as it is currently zoomed.
+ * @param baseline - The value the gesture is judged against. Defaults to `0`.
+ * @param pointsDown - Whether the data hangs below the baseline. Defaults to
+ * `false`.
+ * @returns Whether the y axis comes along.
+ */
+export declare function releasedBeyondBaseline(pointerY: number, yScale: ChartScale, baseline?: number, pointsDown?: boolean): boolean;
+/**
+ * The window a drag asks for, or `null` when it asks for nothing.
+ *
+ * Both corners are pulled back inside the plot before they are read, so a drag
+ * that ran out over the axis labels — which is how the y axis is asked for in
+ * the first place — zooms to the edge of the data rather than to whatever lies
+ * under the margin.
+ *
+ * Whether the baseline is kept in the window is the one thing that differs
+ * between viewers, and `YAxisRules` is where they say so. A stick spectrum keeps
+ * it: sticks are drawn from it, and a window starting at a tenth of the base
+ * peak would cut every one of them off at the ankles. A continuous trace does
+ * not: a band dragged out between two absorbances is asked about between those
+ * two absorbances.
+ * @param current - The window in force, kept on the axis that is not asked for.
+ * @param drag - The two corners, in user units of the SVG.
+ * @param plot - Where the plot sits inside the SVG.
+ * @param xScale - The x axis as it is currently zoomed.
+ * @param yScale - The y axis as it is currently zoomed.
+ * @param rules - How the y axis behaves and what a drag means, defaulting to a
+ * stick spectrum read by dragging its horizontal axis.
+ * @returns The window to show, `null` when the drag was too short to be one.
+ */
+export declare function zoomedDomain(current: ChartDomain, drag: DragBox, plot: PlotRect, xScale: ChartScale, yScale: ChartScale, rules?: ZoomRules): ChartDomain | null;
+/**
+ * The window one turn of the wheel asks for.
+ *
+ * Both bounds are scaled about the baseline rather than about the middle of the
+ * window. On a stick spectrum that keeps the foot the sticks are drawn from on
+ * the axis, and keeps a mirrored chart symmetric — scaling about the middle
+ * would send the two halves apart at different rates, so a peak of one height
+ * would mean two different intensities. On an axis running downwards from a
+ * baseline, such as percent transmittance from 100, it is what stretches the
+ * bands instead of walking the whole trace off the plot.
+ * @param current - The window in force.
+ * @param factor - What one wheel event is worth, above one to zoom out.
+ * @param baseline - The value to scale about. Defaults to `0`.
+ * @returns The window to show, `current` itself when the factor is not one a
+ * window survives.
+ */
+export declare function scaledYAxis(current: ChartDomain, factor: number, baseline?: number): ChartDomain;
+//# sourceMappingURL=zoomDomain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zoomDomain.d.ts","sourceRoot":"","sources":["../../../src/chart/core/zoomDomain.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAGlD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B,+DAA+D;AAC/D,MAAM,WAAW,OAAO;IACtB,4CAA4C;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,8BAA8B;IAC9B,GAAG,EAAE,MAAM,CAAC;CACb;AAED,gFAAgF;AAChF,MAAM,WAAW,aAAc,SAAQ,OAAO;IAC5C;;;OAGG;IACH,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,OAAO,GAAG,IAAI,EACpB,MAAM,EAAE,UAAU,EAClB,KAAK,GAAE,SAAc,GACpB,aAAa,GAAG,IAAI,CAoBtB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,UAAU,EAClB,QAAQ,SAAgC,EACxC,UAAU,UAAkC,GAC3C,OAAO,CAIT;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,WAAW,EACpB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,UAAU,EAClB,KAAK,GAAE,SAAc,GACpB,WAAW,GAAG,IAAI,CA8CpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,MAAM,EACd,QAAQ,SAAgC,GACvC,WAAW,CAOb"}

package/lib/chart/core/zoomDomain.js

@@ -0,0 +1,175 @@
+/**
+ * The window a gesture asks for, where each viewer's own fitting holds the one
+ * the data asks for.
+ *
+ * Nothing here touches React or the DOM: a drag arrives as two corners in the
+ * user units of the SVG, a wheel as a factor, and each leaves as a window — so
+ * what a gesture does to a chart can be read, and tested, without one being on
+ * screen.
+ */
+import { clamp } from "../../format/core/clamp.js";
+import { DEFAULT_Y_AXIS_RULES } from "./chartDomain.js";
+import { chartPixel, chartValue } from "./chartScale.js";
+/**
+ * How far the pointer has to travel before a press counts as a gesture rather
+ * than as a click, in user units of the SVG.
+ *
+ * Across the x axis it is what decides whether there is a window at all: below
+ * this the gesture is a click that happened to wobble — which is most clicks
+ * made on a trackpad — and zooming to it would leave a window a fraction of a
+ * data unit wide, from which the only way back is the double click nobody knows
+ * about yet. `chartGestures.ts` asks the same question of the vertical travel
+ * before it calls a release a click, since a drag of one pixel across and three
+ * hundred down went somewhere.
+ */
+export const MINIMUM_DRAG = 4;
+/**
+ * The drag as the preview rectangle needs it.
+ *
+ * The answer the rectangle changes shape on is worked out once, here, rather
+ * than by the rectangle itself — so what the preview promises and what letting
+ * go actually does are the same test rather than two that have to agree.
+ *
+ * A `select` drag is therefore always a band, however far past the baseline it
+ * strays: its answer is two numbers on one axis, so a preview that grew into a
+ * rectangle would promise a height nobody is ever told about.
+ * @param drag - The drag being made, `null` when none is.
+ * @param yScale - The y axis as it is currently zoomed.
+ * @param rules - How the y axis behaves and what a drag means, defaulting to a
+ * stick spectrum read by dragging its horizontal axis.
+ * @returns The selection to draw, `null` when there is no drag.
+ */
+export function zoomSelection(drag, yScale, rules = {}) {
+    if (drag === null)
+        return null;
+    const { baseline = DEFAULT_Y_AXIS_RULES.baseline, pointsDown = DEFAULT_Y_AXIS_RULES.pointsDown, drag: mode = 'xAxis', } = rules;
+    return {
+        fromX: drag.fromX,
+        fromY: drag.fromY,
+        toX: drag.toX,
+        toY: drag.toY,
+        // The box tool takes the height always, so the preview is a rectangle from
+        // the first pixel of the gesture rather than a full-height band that
+        // suddenly becomes one; a select drag never takes it at all.
+        zoomsYAxis: mode === 'box' ||
+            (mode !== 'select' &&
+                releasedBeyondBaseline(drag.toY, yScale, baseline, pointsDown)),
+    };
+}
+/**
+ * Whether a drag let go here asks for the y axis as well.
+ *
+ * The baseline, not the bottom of the plot: on a mirrored chart zero runs across
+ * the middle, so a drag that dips into the reflected half has crossed it, and on
+ * an ordinary chart the same test means the pointer went below the axis and out
+ * into the margin. One rule, two gestures that both read as "and take the height
+ * with you".
+ *
+ * **Which way "past" points depends on which side of the baseline the data is
+ * on**, which is what `pointsDown` says. Features that stand up out of a
+ * baseline at the foot of the plot — mass sticks, absorbance bands — are passed
+ * by going below it. Percent transmittance hangs down from 100, which sits near
+ * the top of the plot, so there the gesture is a drag released *above* the
+ * baseline; asking the other question would answer yes almost everywhere in the
+ * plot and make every ordinary drag take the value axis with it.
+ * @param pointerY - Where the pointer is, in user units of the SVG.
+ * @param yScale - The y axis as it is currently zoomed.
+ * @param baseline - The value the gesture is judged against. Defaults to `0`.
+ * @param pointsDown - Whether the data hangs below the baseline. Defaults to
+ * `false`.
+ * @returns Whether the y axis comes along.
+ */
+export function releasedBeyondBaseline(pointerY, yScale, baseline = DEFAULT_Y_AXIS_RULES.baseline, pointsDown = DEFAULT_Y_AXIS_RULES.pointsDown) {
+    const atBaseline = chartPixel(yScale, baseline);
+    // SVG counts pixels downwards, so "above the baseline" is the smaller pixel.
+    return pointsDown ? pointerY < atBaseline : pointerY > atBaseline;
+}
+/**
+ * The window a drag asks for, or `null` when it asks for nothing.
+ *
+ * Both corners are pulled back inside the plot before they are read, so a drag
+ * that ran out over the axis labels — which is how the y axis is asked for in
+ * the first place — zooms to the edge of the data rather than to whatever lies
+ * under the margin.
+ *
+ * Whether the baseline is kept in the window is the one thing that differs
+ * between viewers, and `YAxisRules` is where they say so. A stick spectrum keeps
+ * it: sticks are drawn from it, and a window starting at a tenth of the base
+ * peak would cut every one of them off at the ankles. A continuous trace does
+ * not: a band dragged out between two absorbances is asked about between those
+ * two absorbances.
+ * @param current - The window in force, kept on the axis that is not asked for.
+ * @param drag - The two corners, in user units of the SVG.
+ * @param plot - Where the plot sits inside the SVG.
+ * @param xScale - The x axis as it is currently zoomed.
+ * @param yScale - The y axis as it is currently zoomed.
+ * @param rules - How the y axis behaves and what a drag means, defaulting to a
+ * stick spectrum read by dragging its horizontal axis.
+ * @returns The window to show, `null` when the drag was too short to be one.
+ */
+export function zoomedDomain(current, drag, plot, xScale, yScale, rules = {}) {
+    const { baseline = DEFAULT_Y_AXIS_RULES.baseline, keepBaseline = DEFAULT_Y_AXIS_RULES.keepBaseline, pointsDown = DEFAULT_Y_AXIS_RULES.pointsDown, drag: mode = 'xAxis', } = rules;
+    const fromX = clamp(drag.fromX, plot.left, plot.right);
+    const toX = clamp(drag.toX, plot.left, plot.right);
+    if (Math.abs(toX - fromX) < MINIMUM_DRAG)
+        return null;
+    // Sorted after inverting, not before: an axis drawn right to left — an
+    // infrared spectrum runs from 4000 down to 400 — maps the leftmost pixel to
+    // the *highest* value, so taking the left edge as the lower bound would hand
+    // back a window whose ends are the wrong way round, and every scale built
+    // from it would draw the trace mirrored.
+    const firstX = chartValue(xScale, fromX);
+    const secondX = chartValue(xScale, toX);
+    const x = [
+        Math.min(firstX, secondX),
+        Math.max(firstX, secondX),
+    ];
+    // The box tool is asked for the rectangle it was given, wherever it was let
+    // go; the reading gesture takes the height only when it crossed the baseline.
+    if (mode !== 'box' &&
+        !releasedBeyondBaseline(drag.toY, yScale, baseline, pointsDown)) {
+        return { x, y: current.y };
+    }
+    const fromY = chartValue(yScale, clamp(drag.fromY, plot.top, plot.bottom));
+    const toY = chartValue(yScale, clamp(drag.toY, plot.top, plot.bottom));
+    // Both ends, so a baseline the data runs *down* from — 100 percent
+    // transmittance — is kept as surely as one it stands on. The box tool holds no
+    // baseline at all: a rectangle dragged round a feature is a promise about
+    // exactly that rectangle, and a viewer whose axis rules keep its baseline
+    // would otherwise see the tool quietly return a taller window than the one
+    // drawn.
+    const holdBaseline = keepBaseline && mode !== 'box';
+    const bottom = holdBaseline
+        ? Math.min(baseline, fromY, toY)
+        : Math.min(fromY, toY);
+    const top = holdBaseline
+        ? Math.max(baseline, fromY, toY)
+        : Math.max(fromY, toY);
+    return top > bottom ? { x, y: [bottom, top] } : { x, y: current.y };
+}
+/**
+ * The window one turn of the wheel asks for.
+ *
+ * Both bounds are scaled about the baseline rather than about the middle of the
+ * window. On a stick spectrum that keeps the foot the sticks are drawn from on
+ * the axis, and keeps a mirrored chart symmetric — scaling about the middle
+ * would send the two halves apart at different rates, so a peak of one height
+ * would mean two different intensities. On an axis running downwards from a
+ * baseline, such as percent transmittance from 100, it is what stretches the
+ * bands instead of walking the whole trace off the plot.
+ * @param current - The window in force.
+ * @param factor - What one wheel event is worth, above one to zoom out.
+ * @param baseline - The value to scale about. Defaults to `0`.
+ * @returns The window to show, `current` itself when the factor is not one a
+ * window survives.
+ */
+export function scaledYAxis(current, factor, baseline = DEFAULT_Y_AXIS_RULES.baseline) {
+    if (!Number.isFinite(factor) || factor <= 0)
+        return current;
+    const y = [
+        baseline + (current.y[0] - baseline) * factor,
+        baseline + (current.y[1] - baseline) * factor,
+    ];
+    return y[1] > y[0] ? { x: current.x, y } : current;
+}
+//# sourceMappingURL=zoomDomain.js.map

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

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

package/lib/chart/ui/Axes.d.ts

@@ -0,0 +1,104 @@
+import type { ReactElement } from 'react';
+import type { PlotRect } from '../core/chartGeometry.ts';
+import type { ChartScale } from '../core/chartScale.ts';
+export interface AxesProps {
+    /** Where the plot sits inside the SVG. */
+    plot: PlotRect;
+    /** The window on screen, which the ticks along the bottom are chosen for. */
+    xDomain: readonly [number, number];
+    /** The window on screen, which the ticks up the side are chosen for. */
+    yDomain: readonly [number, number];
+    /**
+     * The horizontal axis as it is currently zoomed. A scale built onto a
+     * reversed pixel range is drawn reversed with no further ceremony, which is
+     * what an infrared spectrum running from 4000 down to 400 needs.
+     */
+    xScale: ChartScale;
+    /** The vertical axis as it is currently zoomed. */
+    yScale: ChartScale;
+    /**
+     * Whether the vertical labels are written by magnitude, so the half below
+     * the rule reads `100 50 0 50 100` rather than `-100 -50 0 50 100`. What the
+     * lower half of a mirrored pair means is a second spectrum drawn downwards,
+     * never a negative value, and a minus sign in front of every one of its
+     * labels says otherwise.
+     * @default false
+     */
+    absYTicks?: boolean;
+    /**
+     * Whether the numbers along the bottom are written.
+     *
+     * Panes stacked over one window would each repeat `2.5 5.0 7.5` and spend a
+     * tick row of height on it, so only the pane at the foot writes them. The
+     * grid and the axis line stay — they are what a peak's height is read against.
+     * @default true
+     */
+    showXTicks?: boolean;
+    /**
+     * Whether the name of the horizontal axis is written under it.
+     *
+     * Separate from `showXTicks` because the two go at different moments — a pane
+     * above the foot of a stack keeps neither, a chart in a narrow panel keeps its
+     * numbers. `xTitle` stays required either way: which pane is the foot changes.
+     * @default true
+     */
+    showXTitle?: boolean;
+    /**
+     * What the horizontal axis is called — `m/z`, `wavenumber (cm⁻¹)`.
+     *
+     * Required rather than defaulted, because there is no name that is right for
+     * every spectrum and a default would be one viewer's units silently drawn
+     * under another's data.
+     */
+    xTitle: string;
+    /** What the vertical axis is called — `intensity`, `absorbance`, `%T`. */
+    yTitle: string;
+    /**
+     * How much room one label along the bottom is given, in pixels.
+     *
+     * The default is the width of the widest number a spectrum axis writes — a
+     * mass at four decimals — so that a chart in a narrow panel carries three
+     * labels rather than six run together. A chart whose numbers are known to be
+     * short says so and gets more of them: a fixed axis over a few hundred mass
+     * units writes `400 600 800`, and at the default spacing a column that narrow
+     * is given a single tick, which says nothing about the range at all.
+     * @default 90
+     */
+    xTickSpacing?: number;
+    /**
+     * How much room one label up the side is given, in pixels.
+     * @default 44
+     */
+    yTickSpacing?: number;
+}
+/**
+ * The frame the spectra are read against: two axis lines, a grid, and titles.
+ *
+ * The ticks are rules across the whole plot rather than dashes at its edge. A
+ * feature is read for its height against the ones around it — is this the base
+ * peak, is that band half of it — and a dash on the far left is a measuring
+ * stick nobody can lay across the peak they are looking at. The rules
+ * are drawn in the palest colour the theme carries and under the data band, so
+ * a grid line is never mistaken for a trace.
+ *
+ * Every number is written outside the plot, and every line inside it. That is
+ * what lets the data band be clipped without a label being cut in half, and it
+ * keeps the plot itself free for the only thing it is about.
+ *
+ * The axis pair is one L rather than a box: the top and the right of a spectrum
+ * are open, because a peak that runs out of the top is a peak the zoom has cut
+ * off, and a rule along the top would read as a ceiling the measurement stopped
+ * at.
+ *
+ * How many ticks there are follows the room there is for them — a chart in a
+ * narrow panel is given fewer, rather than the same six labels overprinting one
+ * another — and the precision each is written to comes from the step, so a
+ * window two millimass units wide is labelled to four decimals and a full scan
+ * to none. The notation is settled once per axis rather than per label, so an
+ * intensity axis running to two hundred million reads `5e+7 1e+8 1.5e+8 2e+8`
+ * and not a column of nine digits the title has to be read around.
+ * @param props - Component props.
+ * @returns The axes, as SVG.
+ */
+export declare function Axes(props: AxesProps): ReactElement;
+//# sourceMappingURL=Axes.d.ts.map

package/lib/chart/ui/Axes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Axes.d.ts","sourceRoot":"","sources":["../../../src/chart/ui/Axes.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAM1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAIxD,MAAM,WAAW,SAAS;IACxB,0CAA0C;IAC1C,IAAI,EAAE,QAAQ,CAAC;IACf,6EAA6E;IAC7E,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,wEAAwE;IACxE,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC;;;;OAIG;IACH,MAAM,EAAE,UAAU,CAAC;IACnB,mDAAmD;IACnD,MAAM,EAAE,UAAU,CAAC;IACnB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;OAMG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;;;OAUG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,YAAY,CA+HnD"}