react-cheminfo 0.15.0 → 0.17.0

package/lib/parallel/core/parallelPalette.js

@@ -0,0 +1,81 @@
+/**
+ * The colour each line is drawn in, as a step into a sampled ramp.
+ *
+ * A canvas reassigns `strokeStyle` once per line, and a thousand different
+ * colours is a thousand style writes. Quantising the ramp to 121 steps and
+ * keeping the rows in the order they came means the style is written about
+ * 121 times for the whole figure — while no reader can tell a hundred-and-
+ * twenty-first of a ramp apart from its neighbour.
+ */
+import { evenScale, sampleScale } from "../../color/core/interpolate.js";
+import { positionInRange } from "../../color/core/scale.js";
+import { resolveColorScale } from "../../color/core/scaleText.js";
+import { DEFAULT_COLOR_SCALE_ID } from "../../color/core/scales.js";
+import { parallelExtent } from "./parallelExtent.js";
+/** How many steps the ramp is quantised into; there is one more colour than steps. */
+export const PARALLEL_PALETTE_STEPS = 120;
+/**
+ * The step a row whose colouring quantity is unknown takes.
+ *
+ * Past the end of the ramp on purpose: no colour indexes it, so the painter
+ * leaves such a row in the neutral ink rather than claiming for it the ink of
+ * the smallest value in the set.
+ */
+export const PARALLEL_PALETTE_UNKNOWN = PARALLEL_PALETTE_STEPS + 1;
+/**
+ * The ramp, sampled into the steps a line's colour is looked up by.
+ * @param scale - The ramp, as the registry hands it over or as a plain list of colours. Defaults to viridis.
+ * @returns `PARALLEL_PALETTE_STEPS + 1` colours, from the low end to the high end.
+ */
+export function parallelPalette(scale) {
+    return sampleScale(resolveRamp(scale), PARALLEL_PALETTE_STEPS + 1);
+}
+/**
+ * Which step of the ramp each row takes.
+ *
+ * Worked out once per data change rather than per repaint, and held as bytes:
+ * a library of ten thousand rows costs ten kilobytes and the painter's inner
+ * loop reads an integer instead of placing a value on a ramp.
+ * @param color - The quantity the lines are coloured by.
+ * @param count - How many rows there are.
+ * @returns One step per row, from `0` to {@link PARALLEL_PALETTE_STEPS}, or
+ * {@link PARALLEL_PALETTE_UNKNOWN} for a row whose value is not a number.
+ */
+export function parallelColorSteps(color, count) {
+    const steps = new Uint8Array(count);
+    // A row the column does not reach is as unknown as one holding no number.
+    steps.fill(PARALLEL_PALETTE_UNKNOWN);
+    const extent = parallelExtent(color.values, count);
+    const min = color.min ?? extent.min;
+    const max = color.max ?? extent.max;
+    const logarithmic = color.logarithmic ?? false;
+    const span = max - min;
+    const rows = Math.min(count, color.values.length);
+    for (let row = 0; row < rows; row++) {
+        const value = color.values[row];
+        if (!Number.isFinite(value))
+            continue;
+        steps[row] = logarithmic
+            ? Math.round(positionInRange(value, min, max, { logarithmic: true }) *
+                PARALLEL_PALETTE_STEPS)
+            : colorStep(value, min, span);
+    }
+    return steps;
+}
+function resolveRamp(scale) {
+    if (scale === undefined) {
+        return resolveColorScale(DEFAULT_COLOR_SCALE_ID).scale;
+    }
+    return 'stops' in scale ? scale : evenScale(scale);
+}
+function colorStep(value, min, span) {
+    if (span <= 0)
+        return 0;
+    const ratio = (value - min) / span;
+    if (Number.isNaN(ratio) || ratio < 0)
+        return 0;
+    if (ratio > 1)
+        return PARALLEL_PALETTE_STEPS;
+    return Math.round(ratio * PARALLEL_PALETTE_STEPS);
+}
+//# sourceMappingURL=parallelPalette.js.map

package/lib/parallel/core/parallelPalette.js.map

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

package/lib/parallel/core/parallelSelection.d.ts

@@ -0,0 +1,43 @@
+/**
+ * What an axis keeps, when it keeps more than one interval.
+ *
+ * The figure reports a list and accepts either a list or a bare interval, so a
+ * caller that only ever keeps one is not made to write `[[0, 1]]`. Everything
+ * downstream — the filter, the bands, the gesture — reads the list, which is
+ * what {@link parallelRangeList} is for: one normalisation, at the edge, and
+ * no `Array.isArray` scattered through the painter.
+ *
+ * Intervals on one axis are held sorted and disjoint. Two that touch are one
+ * interval drawn twice, and a reader dragging a band across its neighbour means
+ * to widen it rather than to stack two bands nobody can then take hold of.
+ */
+import type { ParallelRange, ParallelSelection } from './parallelTypes.ts';
+/**
+ * The intervals one axis keeps, however the caller wrote them.
+ * @param selection - One interval, several, or nothing at all.
+ * @returns The intervals, in the order given. Read in place — the caller's own
+ * array comes back when it gave one.
+ */
+export declare function parallelRangeList(selection: ParallelSelection | undefined): readonly ParallelRange[];
+/**
+ * Whether an axis keeps anything at all.
+ * @param selection - What that axis keeps.
+ * @returns Whether any interval is in force.
+ */
+export declare function parallelHasRange(selection: ParallelSelection | undefined): boolean;
+/**
+ * The same intervals, sorted low to high and with the overlapping ones joined.
+ * @param ranges - The intervals, in any order, each low value first.
+ * @returns One list, sorted and disjoint. Intervals that touch at a point are
+ * joined too: a reader who dragged one band onto another meant one band.
+ */
+export declare function parallelMergeRanges(ranges: readonly ParallelRange[]): ParallelRange[];
+/**
+ * The intervals an axis keeps once one of them is replaced, removed or added.
+ * @param ranges - The intervals in force.
+ * @param index - Which one is being written, or `-1` to add one.
+ * @param range - The interval it becomes, or `null` to take it away.
+ * @returns The new list, sorted and disjoint. Never the same array.
+ */
+export declare function parallelWriteRange(ranges: readonly ParallelRange[], index: number, range: ParallelRange | null): ParallelRange[];
+//# sourceMappingURL=parallelSelection.d.ts.map

package/lib/parallel/core/parallelSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelSelection.d.ts","sourceRoot":"","sources":["../../../src/parallel/core/parallelSelection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAK3E;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,iBAAiB,GAAG,SAAS,GACvC,SAAS,aAAa,EAAE,CAO1B;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,iBAAiB,GAAG,SAAS,GACvC,OAAO,CAET;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,aAAa,EAAE,GAC/B,aAAa,EAAE,CAsBjB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,aAAa,GAAG,IAAI,GAC1B,aAAa,EAAE,CAQjB"}

package/lib/parallel/core/parallelSelection.js

@@ -0,0 +1,87 @@
+/**
+ * What an axis keeps, when it keeps more than one interval.
+ *
+ * The figure reports a list and accepts either a list or a bare interval, so a
+ * caller that only ever keeps one is not made to write `[[0, 1]]`. Everything
+ * downstream — the filter, the bands, the gesture — reads the list, which is
+ * what {@link parallelRangeList} is for: one normalisation, at the edge, and
+ * no `Array.isArray` scattered through the painter.
+ *
+ * Intervals on one axis are held sorted and disjoint. Two that touch are one
+ * interval drawn twice, and a reader dragging a band across its neighbour means
+ * to widen it rather than to stack two bands nobody can then take hold of.
+ */
+/** Nothing kept, shared so a normalisation never allocates for the common case. */
+const NONE = [];
+/**
+ * The intervals one axis keeps, however the caller wrote them.
+ * @param selection - One interval, several, or nothing at all.
+ * @returns The intervals, in the order given. Read in place — the caller's own
+ * array comes back when it gave one.
+ */
+export function parallelRangeList(selection) {
+    if (selection === null || selection === undefined)
+        return NONE;
+    if (selection.length === 0)
+        return NONE;
+    // A bare interval is two numbers; a list of them holds arrays.
+    return typeof selection[0] === 'number'
+        ? [selection]
+        : selection;
+}
+/**
+ * Whether an axis keeps anything at all.
+ * @param selection - What that axis keeps.
+ * @returns Whether any interval is in force.
+ */
+export function parallelHasRange(selection) {
+    return parallelRangeList(selection).length > 0;
+}
+/**
+ * The same intervals, sorted low to high and with the overlapping ones joined.
+ * @param ranges - The intervals, in any order, each low value first.
+ * @returns One list, sorted and disjoint. Intervals that touch at a point are
+ * joined too: a reader who dragged one band onto another meant one band.
+ */
+export function parallelMergeRanges(ranges) {
+    if (ranges.length === 0)
+        return [];
+    const sorted = ranges
+        .map((range) => range[0] <= range[1] ? range : [range[1], range[0]])
+        .toSorted((left, right) => left[0] - right[0]);
+    const merged = [];
+    let low = sorted[0][0];
+    let high = sorted[0][1];
+    for (let index = 1; index < sorted.length; index++) {
+        const range = sorted[index];
+        if (range[0] > high) {
+            merged.push([low, high]);
+            low = range[0];
+            high = range[1];
+            continue;
+        }
+        if (range[1] > high)
+            high = range[1];
+    }
+    merged.push([low, high]);
+    return merged;
+}
+/**
+ * The intervals an axis keeps once one of them is replaced, removed or added.
+ * @param ranges - The intervals in force.
+ * @param index - Which one is being written, or `-1` to add one.
+ * @param range - The interval it becomes, or `null` to take it away.
+ * @returns The new list, sorted and disjoint. Never the same array.
+ */
+export function parallelWriteRange(ranges, index, range) {
+    const kept = [];
+    for (let at = 0; at < ranges.length; at++) {
+        if (at === index)
+            continue;
+        kept.push(ranges[at]);
+    }
+    if (range !== null)
+        kept.push(range);
+    return parallelMergeRanges(kept);
+}
+//# sourceMappingURL=parallelSelection.js.map

package/lib/parallel/core/parallelSelection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelSelection.js","sourceRoot":"","sources":["../../../src/parallel/core/parallelSelection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,mFAAmF;AACnF,MAAM,IAAI,GAA6B,EAAE,CAAC;AAE1C;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAC/B,SAAwC;IAExC,IAAI,SAAS,KAAK,IAAI,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IAC/D,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACxC,+DAA+D;IAC/D,OAAO,OAAO,SAAS,CAAC,CAAC,CAAC,KAAK,QAAQ;QACrC,CAAC,CAAC,CAAC,SAA0B,CAAC;QAC9B,CAAC,CAAE,SAAsC,CAAC;AAC9C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAC9B,SAAwC;IAExC,OAAO,iBAAiB,CAAC,SAAS,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;AACjD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CACjC,MAAgC;IAEhC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IACnC,MAAM,MAAM,GAAG,MAAM;SAClB,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CACb,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAmB,CACvE;SACA,QAAQ,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACjD,MAAM,MAAM,GAAoB,EAAE,CAAC;IACnC,IAAI,GAAG,GAAI,MAAM,CAAC,CAAC,CAAmB,CAAC,CAAC,CAAC,CAAC;IAC1C,IAAI,IAAI,GAAI,MAAM,CAAC,CAAC,CAAmB,CAAC,CAAC,CAAC,CAAC;IAC3C,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACnD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAkB,CAAC;QAC7C,IAAI,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC;YACpB,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;YACzB,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACf,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YAChB,SAAS;QACX,CAAC;QACD,IAAI,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI;YAAE,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IACvC,CAAC;IACD,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;IACzB,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAgC,EAChC,KAAa,EACb,KAA2B;IAE3B,MAAM,IAAI,GAAoB,EAAE,CAAC;IACjC,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC;QAC1C,IAAI,EAAE,KAAK,KAAK;YAAE,SAAS;QAC3B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAkB,CAAC,CAAC;IACzC,CAAC;IACD,IAAI,KAAK,KAAK,IAAI;QAAE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACrC,OAAO,mBAAmB,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC"}

package/lib/parallel/core/parallelTicks.d.ts

@@ -0,0 +1,34 @@
+/**
+ * How one axis is graduated.
+ *
+ * Five evenly spaced marks across the raw extent, not `chartAxisScale`'s nice
+ * ones: nicing moves the ends of the axis, and a figure whose whole job is to
+ * compare rows against each other must end exactly where the data does. A
+ * caller who wants round numbers asks for them with `nice`, per axis.
+ */
+import type { ParallelAxis, ParallelTick } from './parallelTypes.ts';
+/** How many graduations an axis carries when the caller asks for no number. */
+export declare const PARALLEL_TICK_COUNT = 5;
+/** An axis's ends and the graduations written along it. */
+export interface ParallelGraduation {
+    /** The two ends of the axis, low first, after any nicing. */
+    domain: readonly [number, number];
+    /** The graduations, from the bottom of the axis to the top. */
+    ticks: readonly ParallelTick[];
+}
+/**
+ * The graduations of one axis, and the ends they are spread between.
+ *
+ * Three ways, in order: the caller's own list wins outright — a coded quantity
+ * reading `none`, `low`, `high` is nobody else's to invent; `nice` hands the
+ * axis to `chartAxisScale`, which rounds both ends outward to whole steps; and
+ * otherwise the extent is divided evenly and a mark whose label repeats the
+ * one below it is dropped, so an axis of whole numbers from 0 to 2 reads
+ * `0 1 2` rather than writing `1` twice.
+ * @param axis - The axis, for its formatting and how many marks it wants.
+ * @param min - The value at the bottom of the axis.
+ * @param max - The value at its top.
+ * @returns The ends and the graduations. See {@link ParallelGraduation}.
+ */
+export declare function parallelTicks(axis: ParallelAxis, min: number, max: number): ParallelGraduation;
+//# sourceMappingURL=parallelTicks.d.ts.map

package/lib/parallel/core/parallelTicks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelTicks.d.ts","sourceRoot":"","sources":["../../../src/parallel/core/parallelTicks.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAUH,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAErE,+EAA+E;AAC/E,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAQrC,2DAA2D;AAC3D,MAAM,WAAW,kBAAkB;IACjC,6DAA6D;IAC7D,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,+DAA+D;IAC/D,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;CAChC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,YAAY,EAClB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACV,kBAAkB,CAWpB"}

package/lib/parallel/core/parallelTicks.js

@@ -0,0 +1,119 @@
+/**
+ * How one axis is graduated.
+ *
+ * Five evenly spaced marks across the raw extent, not `chartAxisScale`'s nice
+ * ones: nicing moves the ends of the axis, and a figure whose whole job is to
+ * compare rows against each other must end exactly where the data does. A
+ * caller who wants round numbers asks for them with `nice`, per axis.
+ */
+import { chartAxisScale, chartTickDecimals, chartTickLabel, } from "../../chart/core/chartAxisScale.js";
+import { formatDecimal } from "../../format/core/numbers.js";
+import { roundTo } from "../../format/core/roundTo.js";
+/** How many graduations an axis carries when the caller asks for no number. */
+export const PARALLEL_TICK_COUNT = 5;
+/** The most decimals a graduation is ever written with. */
+const MOST_TICK_DECIMALS = 6;
+/** How far a label may sit from its own value: a tenth of the spacing. */
+const LABEL_TOLERANCE = 10;
+/**
+ * The graduations of one axis, and the ends they are spread between.
+ *
+ * Three ways, in order: the caller's own list wins outright — a coded quantity
+ * reading `none`, `low`, `high` is nobody else's to invent; `nice` hands the
+ * axis to `chartAxisScale`, which rounds both ends outward to whole steps; and
+ * otherwise the extent is divided evenly and a mark whose label repeats the
+ * one below it is dropped, so an axis of whole numbers from 0 to 2 reads
+ * `0 1 2` rather than writing `1` twice.
+ * @param axis - The axis, for its formatting and how many marks it wants.
+ * @param min - The value at the bottom of the axis.
+ * @param max - The value at its top.
+ * @returns The ends and the graduations. See {@link ParallelGraduation}.
+ */
+export function parallelTicks(axis, min, max) {
+    const domain = [min, max];
+    if (axis.ticks !== undefined)
+        return { domain, ticks: axis.ticks };
+    const wanted = Math.max(2, Math.trunc(axis.tickCount ?? PARALLEL_TICK_COUNT));
+    if (axis.nice === true && axis.scale !== 'log') {
+        return nicedGraduation(axis, min, max, wanted);
+    }
+    const values = evenValues(min, max, wanted, axis.scale === 'log');
+    return { domain, ticks: labelled(values, axis.format) };
+}
+function nicedGraduation(axis, min, max, wanted) {
+    const scale = chartAxisScale(min, max, { count: wanted, nice: true });
+    // Not `scale.labels`: those have a common power of ten lifted out of them,
+    // on the understanding that the caller writes it beside the axis name, and
+    // this figure writes only the name. Each graduation carries its own value.
+    const decimals = chartTickDecimals(scale.step);
+    const ticks = [];
+    for (const value of scale.values) {
+        const label = axis.format === undefined
+            ? chartTickLabel(value, decimals)
+            : axis.format(value);
+        if (ticks.at(-1)?.label === label)
+            continue;
+        ticks.push({ value, label });
+    }
+    return { domain: scale.domain, ticks };
+}
+function evenValues(min, max, wanted, logarithmic) {
+    const values = [];
+    const low = logarithmic ? Math.log10(Math.max(min, smallestStep(max))) : min;
+    const high = logarithmic ? Math.log10(Math.max(max, smallestStep(max))) : max;
+    const span = high - low;
+    for (let index = 0; index < wanted; index++) {
+        const placed = low + (span * index) / (wanted - 1);
+        values.push(logarithmic ? 10 ** placed : placed);
+    }
+    return values;
+}
+function labelled(values, format) {
+    const decimals = format === undefined ? tickDecimals(values) : 0;
+    const ticks = [];
+    for (const value of values) {
+        const label = format === undefined ? formatDecimal(value, decimals) : format(value);
+        if (ticks.at(-1)?.label === label)
+            continue;
+        ticks.push({ value, label });
+    }
+    return ticks;
+}
+/**
+ * As many decimals as the spacing needs, and one more whenever rounding would
+ * move a mark by more than a tenth of that spacing — which is what keeps an
+ * axis from 12.3 to 157 reading `12 48 85 121 157` while one from −1.5 to 2.5
+ * still reads `−1.5 −0.5 0.5 1.5 2.5` rather than rounding both away.
+ * @param values - The graduations, in the axis's own units.
+ * @returns How many decimals each of their labels carries.
+ */
+function tickDecimals(values) {
+    const step = smallestGap(values);
+    const tolerance = step / LABEL_TOLERANCE;
+    let decimals = chartTickDecimals(step);
+    while (decimals < MOST_TICK_DECIMALS &&
+        !faithful(values, decimals, tolerance)) {
+        decimals++;
+    }
+    return decimals;
+}
+function faithful(values, decimals, tolerance) {
+    for (const value of values) {
+        if (Math.abs(value - roundTo(value, decimals)) > tolerance)
+            return false;
+    }
+    return true;
+}
+function smallestGap(values) {
+    let smallest = Number.POSITIVE_INFINITY;
+    for (let index = 1; index < values.length; index++) {
+        const gap = Math.abs(values[index] - values[index - 1]);
+        if (gap > 0 && gap < smallest)
+            smallest = gap;
+    }
+    return Number.isFinite(smallest) ? smallest : 1;
+}
+function smallestStep(max) {
+    return max > 0 ? max * 1e-12 : 1;
+}
+//# sourceMappingURL=parallelTicks.js.map

package/lib/parallel/core/parallelTicks.js.map

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

package/lib/parallel/core/parallelTypes.d.ts

@@ -0,0 +1,140 @@
+/**
+ * What a parallel-coordinates figure is asked to draw: one axis per column,
+ * the intervals the reader brushed on them, and the quantity the lines are
+ * coloured by.
+ *
+ * The figure itself is index-based — every axis hands over its column as an
+ * `ArrayLike<number>` read in place — so a repaint costs an indexed read per
+ * value rather than a call. {@link parallelAxisOf} is the one place a row type
+ * is named, and it is run once per data change rather than once per repaint.
+ */
+import type { ColorScale } from '../../color/core/interpolate.ts';
+/** How a value is placed along an axis. */
+export type ParallelAxisScale = 'linear' | 'log';
+/** One labelled graduation a caller writes itself. */
+export interface ParallelTick {
+    /** Where it sits, in the axis's own units. */
+    value: number;
+    /** What is written beside it. */
+    label: string;
+}
+/** One vertical axis of a parallel-coordinates figure, and the column it draws. */
+export interface ParallelAxis {
+    /**
+     * A stable key, which is how a brushed range is reported and how a caller
+     * names the axis the colour is read from. Never an index: axes are added and
+     * reordered, and a range keyed on a position outlives the axis it belonged
+     * to.
+     */
+    id: string;
+    /** What it is called, written over the axis. */
+    label: string;
+    /**
+     * Every row's value, in the figure's row order. Read in place — nothing is
+     * copied — so a `Float64Array` is the cheapest thing to pass.
+     */
+    values: ArrayLike<number>;
+    /**
+     * The two ends of the axis, low first. Left out, they are the column's own
+     * smallest and largest finite value, and a column with no spread at all is
+     * opened by half a unit on each side so that it still draws.
+     * @default undefined — the column's own range
+     */
+    domain?: readonly [number, number];
+    /**
+     * How values are placed between the ends. `log` needs a domain whose low end
+     * is above zero; a value at or below zero is pinned to the low end.
+     * @default 'linear'
+     */
+    scale?: ParallelAxisScale;
+    /**
+     * How a tick is written. Left out, the ticks carry as many decimals as the
+     * spacing needs.
+     * @default undefined
+     */
+    format?: (value: number) => string;
+    /**
+     * The graduations, written out by the caller — what a coded quantity needs,
+     * where `0`, `1`, `2` should read `none`, `low`, `high`.
+     * @default undefined — the figure graduates the axis itself
+     */
+    ticks?: readonly ParallelTick[];
+    /**
+     * Roughly how many graduations to aim for, when the figure picks them.
+     * @default 5
+     */
+    tickCount?: number;
+    /**
+     * Whether the ends are rounded outward to whole tick steps. Off, so the axis
+     * ends exactly on the data — a reader comparing two molecules on a drug
+     * score must see the best one touch the top of its axis, not float below a
+     * round number nothing reached.
+     * @default false
+     */
+    nice?: boolean;
+    /**
+     * The unit written after the axis name, e.g. `g/mol`.
+     * @default '' — nothing is written
+     */
+    unit?: string;
+}
+/** An interval kept on one axis, in that axis's own units, low first. */
+export type ParallelRange = readonly [number, number];
+/**
+ * What one axis keeps: nothing, one interval, or several disjoint ones.
+ *
+ * A reader comparing molecules wants the light ones *and* the heavy ones, with
+ * nothing in between, which one interval cannot say. Several are read as a
+ * union — a row is kept when it falls in any of them — while the axes are
+ * still read as an intersection, so each axis narrows what the ones before it
+ * left. A bare interval means the same as a list holding only it, so a caller
+ * that only ever keeps one writes one.
+ */
+export type ParallelSelection = ParallelRange | readonly ParallelRange[] | null;
+/** Which rows a set of brushes keeps, keyed by axis id. */
+export type ParallelRanges = Readonly<Record<string, ParallelSelection>>;
+/** How the lines are coloured. */
+export interface ParallelColorBy {
+    /** The quantity read for each row, in the figure's row order. */
+    values: ArrayLike<number>;
+    /**
+     * The value at the low end of the ramp.
+     * @default the smallest finite value
+     */
+    min?: number;
+    /**
+     * The value at its high end.
+     * @default the largest finite value
+     */
+    max?: number;
+    /**
+     * The ramp, as the registry hands it over or as a plain list of colours.
+     * @default viridis — `resolveColorScale(DEFAULT_COLOR_SCALE_ID).scale`
+     */
+    scale?: ColorScale | readonly string[];
+    /**
+     * Whether the quantity is read on a base-10 logarithmic ramp.
+     * @default false
+     */
+    logarithmic?: boolean;
+}
+/** An axis described by the field to read off each row, rather than by its column. */
+export type ParallelAxisSource<Row> = Omit<ParallelAxis, 'values'> & {
+    /**
+     * The value this axis reads off one row. Called once per row per data
+     * change, never per repaint.
+     */
+    readonly value: (row: Row) => number;
+};
+/**
+ * One axis built by reading a field off each row.
+ *
+ * The one place a row type is named: the figure itself reads numbers out of a
+ * typed array, so a repaint costs an indexed read rather than a call per
+ * value. Call it inside a `useMemo` keyed on the rows.
+ * @param rows - The rows, in the order the figure will index them.
+ * @param axis - The axis, with the field to read instead of its values.
+ * @returns The axis, with its values filled in.
+ */
+export declare function parallelAxisOf<Row>(rows: readonly Row[], axis: ParallelAxisSource<Row>): ParallelAxis;
+//# sourceMappingURL=parallelTypes.d.ts.map

package/lib/parallel/core/parallelTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelTypes.d.ts","sourceRoot":"","sources":["../../../src/parallel/core/parallelTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAElE,2CAA2C;AAC3C,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,KAAK,CAAC;AAEjD,sDAAsD;AACtD,MAAM,WAAW,YAAY;IAC3B,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAC;IACd,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;CACf;AAED,mFAAmF;AACnF,MAAM,WAAW,YAAY;IAC3B;;;;;OAKG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAC1B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC;;;;OAIG;IACH,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B;;;;OAIG;IACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACnC;;;;OAIG;IACH,KAAK,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAChC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,yEAAyE;AACzE,MAAM,MAAM,aAAa,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEtD;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG,SAAS,aAAa,EAAE,GAAG,IAAI,CAAC;AAEhF,2DAA2D;AAC3D,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;AAEzE,kCAAkC;AAClC,MAAM,WAAW,eAAe;IAC9B,iEAAiE;IACjE,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAC1B;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,KAAK,CAAC,EAAE,UAAU,GAAG,SAAS,MAAM,EAAE,CAAC;IACvC;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,sFAAsF;AACtF,MAAM,MAAM,kBAAkB,CAAC,GAAG,IAAI,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,GAAG;IACnE;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC;CACtC,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAChC,IAAI,EAAE,SAAS,GAAG,EAAE,EACpB,IAAI,EAAE,kBAAkB,CAAC,GAAG,CAAC,GAC5B,YAAY,CAOd"}

package/lib/parallel/core/parallelTypes.js

@@ -0,0 +1,29 @@
+/**
+ * What a parallel-coordinates figure is asked to draw: one axis per column,
+ * the intervals the reader brushed on them, and the quantity the lines are
+ * coloured by.
+ *
+ * The figure itself is index-based — every axis hands over its column as an
+ * `ArrayLike<number>` read in place — so a repaint costs an indexed read per
+ * value rather than a call. {@link parallelAxisOf} is the one place a row type
+ * is named, and it is run once per data change rather than once per repaint.
+ */
+/**
+ * One axis built by reading a field off each row.
+ *
+ * The one place a row type is named: the figure itself reads numbers out of a
+ * typed array, so a repaint costs an indexed read rather than a call per
+ * value. Call it inside a `useMemo` keyed on the rows.
+ * @param rows - The rows, in the order the figure will index them.
+ * @param axis - The axis, with the field to read instead of its values.
+ * @returns The axis, with its values filled in.
+ */
+export function parallelAxisOf(rows, axis) {
+    const { value, ...rest } = axis;
+    const values = new Float64Array(rows.length);
+    for (let row = 0; row < rows.length; row++) {
+        values[row] = value(rows[row]);
+    }
+    return { ...rest, values };
+}
+//# sourceMappingURL=parallelTypes.js.map

package/lib/parallel/core/parallelTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelTypes.js","sourceRoot":"","sources":["../../../src/parallel/core/parallelTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAiIH;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAC5B,IAAoB,EACpB,IAA6B;IAE7B,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC;IAChC,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC7C,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC;QAC3C,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAQ,CAAC,CAAC;IACxC,CAAC;IACD,OAAO,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC;AAC7B,CAAC"}

package/lib/parallel/ui/ParallelAxesLayer.d.ts

@@ -0,0 +1,28 @@
+import type { ReactElement } from 'react';
+import type { ParallelAxisLayout } from '../core/parallelAxes.ts';
+import type { ParallelBand } from '../core/parallelBrush.ts';
+/** What {@link ParallelAxesLayer} draws. */
+export interface ParallelAxesLayerProps {
+    /** The axes, from left to right, already placed and graduated. */
+    layouts: readonly ParallelAxisLayout[];
+    /** Height of the drawing area, in pixels. */
+    innerHeight: number;
+    /** The bands each axis carries right now, the one being dragged included. */
+    bands: ReadonlyMap<string, ParallelBand[]>;
+    /** The ink the axes, their ticks and their labels are drawn in. */
+    axisInk: string;
+    /** The ink a band is filled and outlined in. */
+    bandInk: string;
+}
+/**
+ * The axes, their graduations and the intervals brushed on them.
+ *
+ * Every axis carries a `data-parallel-brush` rectangle over the strip a press
+ * on it reaches, which nothing points at: one surface over the whole figure
+ * takes every event, so the rectangle exists to be found — by a test driving
+ * a drag, and by a reader's eye, which is the same thing.
+ * @param props - See {@link ParallelAxesLayerProps}.
+ * @returns The axes.
+ */
+export declare function ParallelAxesLayer(props: ParallelAxesLayerProps): ReactElement;
+//# sourceMappingURL=ParallelAxesLayer.d.ts.map

package/lib/parallel/ui/ParallelAxesLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParallelAxesLayer.d.ts","sourceRoot":"","sources":["../../../src/parallel/ui/ParallelAxesLayer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAE1C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAY7D,4CAA4C;AAC5C,MAAM,WAAW,sBAAsB;IACrC,kEAAkE;IAClE,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACvC,6CAA6C;IAC7C,WAAW,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;IAC3C,mEAAmE;IACnE,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG,YAAY,CAyD7E"}

package/lib/parallel/ui/ParallelAxesLayer.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { PARALLEL_MARGIN, parallelValueToY } from "../core/parallelAxes.js";
+import { PARALLEL_BRUSH_HALF_WIDTH } from "../core/parallelBrush.js";
+import { PARALLEL_HANDLE_HEIGHT, PARALLEL_TICK_LABEL_INSET, PARALLEL_TICK_LABEL_STYLE, PARALLEL_TICK_LENGTH, parallelBandStyle, parallelHandleStyle, } from "./parallelStyles.js";
+/**
+ * The axes, their graduations and the intervals brushed on them.
+ *
+ * Every axis carries a `data-parallel-brush` rectangle over the strip a press
+ * on it reaches, which nothing points at: one surface over the whole figure
+ * takes every event, so the rectangle exists to be found — by a test driving
+ * a drag, and by a reader's eye, which is the same thing.
+ * @param props - See {@link ParallelAxesLayerProps}.
+ * @returns The axes.
+ */
+export function ParallelAxesLayer(props) {
+    const { layouts, innerHeight, bands, axisInk, bandInk } = props;
+    const stroke = { stroke: axisInk };
+    return (_jsx("g", { transform: `translate(${PARALLEL_MARGIN.left},${PARALLEL_MARGIN.top})`, style: { fill: axisInk }, textAnchor: "middle", children: layouts.map((layout) => {
+            const drawn = bands.get(layout.id);
+            return (_jsxs("g", { className: "parallel-axis", "data-parallel-axis": layout.id, transform: `translate(${layout.x},0)`, children: [_jsx("line", { y2: innerHeight, style: stroke }), layout.ticks.map((tick) => (_jsxs("g", { transform: `translate(0,${parallelValueToY(tick.value, layout)})`, children: [_jsx("line", { x1: -PARALLEL_TICK_LENGTH, style: stroke }), _jsx("text", { x: -PARALLEL_TICK_LABEL_INSET, dy: "0.32em", textAnchor: "end", style: PARALLEL_TICK_LABEL_STYLE, children: tick.label })] }, tick.value))), _jsx("rect", { "data-parallel-brush": layout.id, x: -PARALLEL_BRUSH_HALF_WIDTH, y: 0, width: PARALLEL_BRUSH_HALF_WIDTH * 2, height: Math.max(0, innerHeight), fill: "transparent", pointerEvents: "none" }), drawn?.map((band) => (_jsx(BrushBand, { band: band, ink: bandInk }, `${band.top}:${band.bottom}`)))] }, layout.id));
+        }) }));
+}
+function BrushBand(props) {
+    const { band, ink } = props;
+    const height = Math.max(0, band.bottom - band.top);
+    const width = PARALLEL_BRUSH_HALF_WIDTH * 2;
+    return (_jsxs("g", { className: "parallel-axis-band", pointerEvents: "none", children: [_jsx("rect", { x: -PARALLEL_BRUSH_HALF_WIDTH, y: band.top, width: width, height: height, style: parallelBandStyle(ink) }), _jsx("rect", { x: -PARALLEL_BRUSH_HALF_WIDTH, y: band.top - PARALLEL_HANDLE_HEIGHT / 2, width: width, height: PARALLEL_HANDLE_HEIGHT, style: parallelHandleStyle(ink) }), _jsx("rect", { x: -PARALLEL_BRUSH_HALF_WIDTH, y: band.bottom - PARALLEL_HANDLE_HEIGHT / 2, width: width, height: PARALLEL_HANDLE_HEIGHT, style: parallelHandleStyle(ink) })] }));
+}
+//# sourceMappingURL=ParallelAxesLayer.js.map

package/lib/parallel/ui/ParallelAxesLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParallelAxesLayer.js","sourceRoot":"","sources":["../../../src/parallel/ui/ParallelAxesLayer.tsx"],"names":[],"mappings":"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"}