react-cheminfo 0.15.0 → 0.17.0

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

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

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

@@ -0,0 +1,47 @@
+/**
+ * Which row the pointer is over.
+ *
+ * Only the segment between the two axes the pointer sits between is tested, so
+ * the cost is one distance per row whatever the number of axes. The vertical
+ * gap to the segment is projected onto its normal, so a steep line is no
+ * harder to pick than a flat one — without which the only rows a reader can
+ * ever point at are the uninteresting ones.
+ */
+import type { ParallelAxisLayout } from './parallelAxes.ts';
+/** How far the pointer may sit from a line and still pick it, in pixels. */
+export declare const PARALLEL_HOVER_TOLERANCE = 6;
+/** A pointer position, relative to the top left of the drawing area. */
+export interface ParallelPoint {
+    /** Pixels from the left of the drawing area. */
+    x: number;
+    /** Pixels from its top. */
+    y: number;
+}
+/** The pair of axes a pointer sits between, as indices into the layouts. */
+export interface ParallelSegment {
+    /** The axis to the left of the pointer. */
+    left: number;
+    /** The axis to its right. */
+    right: number;
+}
+/**
+ * The pair of axes a horizontal position sits between.
+ * @param x - Pixels from the left of the drawing area.
+ * @param axes - The axes, from left to right.
+ * @param tolerance - How far past the first and the last axis still counts. Defaults to {@link PARALLEL_HOVER_TOLERANCE}.
+ * @returns The pair, or `null` when there are fewer than two axes or the
+ * position is past either end of the figure.
+ */
+export declare function parallelSegmentAt(x: number, axes: readonly ParallelAxisLayout[], tolerance?: number): ParallelSegment | null;
+/**
+ * The row whose line runs closest to the pointer.
+ * @param point - Where the pointer is, relative to the drawing area.
+ * @param axes - The axes, from left to right.
+ * @param values - Each axis's column, in the same order.
+ * @param count - How many rows are drawn.
+ * @param included - Which rows a brush keeps, a zero meaning the row is not pickable. Defaults to every row.
+ * @param tolerance - How far the pointer may sit from a line. Defaults to {@link PARALLEL_HOVER_TOLERANCE}.
+ * @returns The row, or `-1` when the pointer is over no line.
+ */
+export declare function parallelNearestRow(point: ParallelPoint, axes: readonly ParallelAxisLayout[], values: ReadonlyArray<ArrayLike<number>>, count: number, included?: Uint8Array, tolerance?: number): number;
+//# sourceMappingURL=parallelHit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parallelHit.d.ts","sourceRoot":"","sources":["../../../src/parallel/core/parallelHit.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAG5D,4EAA4E;AAC5E,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,wEAAwE;AACxE,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,CAAC,EAAE,MAAM,CAAC;IACV,2BAA2B;IAC3B,CAAC,EAAE,MAAM,CAAC;CACX;AAED,4EAA4E;AAC5E,MAAM,WAAW,eAAe;IAC9B,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,SAAS,kBAAkB,EAAE,EACnC,SAAS,GAAE,MAAiC,GAC3C,eAAe,GAAG,IAAI,CAaxB;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,SAAS,kBAAkB,EAAE,EACnC,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EACxC,KAAK,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,UAAU,EACrB,SAAS,GAAE,MAAiC,GAC3C,MAAM,CA6BR"}

package/lib/parallel/core/parallelHit.js

@@ -0,0 +1,81 @@
+/**
+ * Which row the pointer is over.
+ *
+ * Only the segment between the two axes the pointer sits between is tested, so
+ * the cost is one distance per row whatever the number of axes. The vertical
+ * gap to the segment is projected onto its normal, so a steep line is no
+ * harder to pick than a flat one — without which the only rows a reader can
+ * ever point at are the uninteresting ones.
+ */
+import { parallelPixelAt } from "./parallelAxes.js";
+/** How far the pointer may sit from a line and still pick it, in pixels. */
+export const PARALLEL_HOVER_TOLERANCE = 6;
+/**
+ * The pair of axes a horizontal position sits between.
+ * @param x - Pixels from the left of the drawing area.
+ * @param axes - The axes, from left to right.
+ * @param tolerance - How far past the first and the last axis still counts. Defaults to {@link PARALLEL_HOVER_TOLERANCE}.
+ * @returns The pair, or `null` when there are fewer than two axes or the
+ * position is past either end of the figure.
+ */
+export function parallelSegmentAt(x, axes, tolerance = PARALLEL_HOVER_TOLERANCE) {
+    const first = axes[0];
+    const last = axes.at(-1);
+    if (first === undefined || last === undefined || axes.length < 2)
+        return null;
+    if (x < first.x - tolerance || x > last.x + tolerance)
+        return null;
+    for (let index = 1; index < axes.length; index++) {
+        const right = axes[index];
+        if (right === undefined)
+            continue;
+        if (x <= right.x || index === axes.length - 1) {
+            return { left: index - 1, right: index };
+        }
+    }
+    return null;
+}
+/**
+ * The row whose line runs closest to the pointer.
+ * @param point - Where the pointer is, relative to the drawing area.
+ * @param axes - The axes, from left to right.
+ * @param values - Each axis's column, in the same order.
+ * @param count - How many rows are drawn.
+ * @param included - Which rows a brush keeps, a zero meaning the row is not pickable. Defaults to every row.
+ * @param tolerance - How far the pointer may sit from a line. Defaults to {@link PARALLEL_HOVER_TOLERANCE}.
+ * @returns The row, or `-1` when the pointer is over no line.
+ */
+export function parallelNearestRow(point, axes, values, count, included, tolerance = PARALLEL_HOVER_TOLERANCE) {
+    const segment = parallelSegmentAt(point.x, axes, tolerance);
+    if (segment === null)
+        return -1;
+    const left = axes[segment.left];
+    const right = axes[segment.right];
+    const leftColumn = values[segment.left];
+    const rightColumn = values[segment.right];
+    if (left === undefined || right === undefined)
+        return -1;
+    if (leftColumn === undefined || rightColumn === undefined)
+        return -1;
+    const width = right.x - left.x;
+    if (width <= 0)
+        return -1;
+    const ratio = (point.x - left.x) / width;
+    const rows = Math.min(count, leftColumn.length, rightColumn.length);
+    let nearest = -1;
+    let nearestDistance = tolerance;
+    for (let row = 0; row < rows; row++) {
+        if (included?.[row] === 0)
+            continue;
+        const leftY = parallelPixelAt(left.pixels, leftColumn[row]);
+        const rightY = parallelPixelAt(right.pixels, rightColumn[row]);
+        const gap = Math.abs(leftY + (rightY - leftY) * ratio - point.y);
+        const distance = (gap * width) / Math.hypot(width, rightY - leftY);
+        if (distance < nearestDistance) {
+            nearestDistance = distance;
+            nearest = row;
+        }
+    }
+    return nearest;
+}
+//# sourceMappingURL=parallelHit.js.map

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

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

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

@@ -0,0 +1,36 @@
+/**
+ * Which order the axes stand in, when the reader is the one deciding.
+ *
+ * A parallel-coordinates figure only shows a relationship between two columns
+ * that stand next to each other, so the order is not decoration: moving an
+ * axis is how a reader asks a different question of the same data. The
+ * arithmetic of the move is here, away from the pointer that starts it, so
+ * that dragging a name and pressing an arrow key are the same operation.
+ */
+import type { ParallelAxisLayout } from './parallelAxes.ts';
+/**
+ * The same ids with one of them moved.
+ * @param ids - The axes, from left to right.
+ * @param from - Which one is moving.
+ * @param to - The place it lands in, counted in the list it left.
+ * @returns The new order. The list comes back unchanged when either place is
+ * outside it or when nothing moves, so a caller can report without comparing.
+ */
+export declare function parallelMoveAxis(ids: readonly string[], from: number, to: number): string[];
+/**
+ * Where an axis dragged to that position would land.
+ * @param x - Where the pointer is, in pixels from the left of the drawing area.
+ * @param layouts - The axes, from left to right.
+ * @returns The index of the axis whose place it would take, or `-1` when there
+ * is nowhere to land. Nearest axis rather than nearest gap: a reader dragging
+ * a name over its neighbour means the two to swap, and the neighbour's own
+ * name is the thing they are aiming at.
+ */
+export declare function parallelDropIndex(x: number, layouts: readonly ParallelAxisLayout[]): number;
+/**
+ * The ids of the axes, from left to right.
+ * @param layouts - The axes, already placed.
+ * @returns Their ids, which is what an order is reported as.
+ */
+export declare function parallelAxisOrder(layouts: readonly ParallelAxisLayout[]): string[];
+//# sourceMappingURL=parallelOrder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parallelOrder.d.ts","sourceRoot":"","sources":["../../../src/parallel/core/parallelOrder.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE5D;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,SAAS,MAAM,EAAE,EACtB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,MAAM,EAAE,CAQV;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,MAAM,EACT,OAAO,EAAE,SAAS,kBAAkB,EAAE,GACrC,MAAM,CAaR;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,kBAAkB,EAAE,GACrC,MAAM,EAAE,CAIV"}

package/lib/parallel/core/parallelOrder.js

@@ -0,0 +1,65 @@
+/**
+ * Which order the axes stand in, when the reader is the one deciding.
+ *
+ * A parallel-coordinates figure only shows a relationship between two columns
+ * that stand next to each other, so the order is not decoration: moving an
+ * axis is how a reader asks a different question of the same data. The
+ * arithmetic of the move is here, away from the pointer that starts it, so
+ * that dragging a name and pressing an arrow key are the same operation.
+ */
+/**
+ * The same ids with one of them moved.
+ * @param ids - The axes, from left to right.
+ * @param from - Which one is moving.
+ * @param to - The place it lands in, counted in the list it left.
+ * @returns The new order. The list comes back unchanged when either place is
+ * outside it or when nothing moves, so a caller can report without comparing.
+ */
+export function parallelMoveAxis(ids, from, to) {
+    const order = [...ids];
+    if (from < 0 || from >= order.length)
+        return order;
+    if (to < 0 || to >= order.length || to === from)
+        return order;
+    const [moved] = order.splice(from, 1);
+    if (moved === undefined)
+        return [...ids];
+    order.splice(to, 0, moved);
+    return order;
+}
+/**
+ * Where an axis dragged to that position would land.
+ * @param x - Where the pointer is, in pixels from the left of the drawing area.
+ * @param layouts - The axes, from left to right.
+ * @returns The index of the axis whose place it would take, or `-1` when there
+ * is nowhere to land. Nearest axis rather than nearest gap: a reader dragging
+ * a name over its neighbour means the two to swap, and the neighbour's own
+ * name is the thing they are aiming at.
+ */
+export function parallelDropIndex(x, layouts) {
+    let nearest = -1;
+    let nearestDistance = Number.POSITIVE_INFINITY;
+    for (let index = 0; index < layouts.length; index++) {
+        const layout = layouts[index];
+        if (layout === undefined)
+            continue;
+        const distance = Math.abs(x - layout.x);
+        if (distance < nearestDistance) {
+            nearestDistance = distance;
+            nearest = index;
+        }
+    }
+    return nearest;
+}
+/**
+ * The ids of the axes, from left to right.
+ * @param layouts - The axes, already placed.
+ * @returns Their ids, which is what an order is reported as.
+ */
+export function parallelAxisOrder(layouts) {
+    const ids = [];
+    for (const layout of layouts)
+        ids.push(layout.id);
+    return ids;
+}
+//# sourceMappingURL=parallelOrder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parallelOrder.js","sourceRoot":"","sources":["../../../src/parallel/core/parallelOrder.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAC9B,GAAsB,EACtB,IAAY,EACZ,EAAU;IAEV,MAAM,KAAK,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC;IACvB,IAAI,IAAI,GAAG,CAAC,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM;QAAE,OAAO,KAAK,CAAC;IACnD,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,IAAI,KAAK,CAAC,MAAM,IAAI,EAAE,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9D,MAAM,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACtC,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC;IACzC,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;IAC3B,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAC/B,CAAS,EACT,OAAsC;IAEtC,IAAI,OAAO,GAAG,CAAC,CAAC,CAAC;IACjB,IAAI,eAAe,GAAG,MAAM,CAAC,iBAAiB,CAAC;IAC/C,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACpD,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;QAC9B,IAAI,MAAM,KAAK,SAAS;YAAE,SAAS;QACnC,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACxC,IAAI,QAAQ,GAAG,eAAe,EAAE,CAAC;YAC/B,eAAe,GAAG,QAAQ,CAAC;YAC3B,OAAO,GAAG,KAAK,CAAC;QAClB,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAC/B,OAAsC;IAEtC,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,KAAK,MAAM,MAAM,IAAI,OAAO;QAAE,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IAClD,OAAO,GAAG,CAAC;AACb,CAAC"}

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

@@ -0,0 +1,108 @@
+/**
+ * The lines, painted into a canvas.
+ *
+ * The first canvas figure in the family, and for one reason: ten thousand
+ * polylines of a dozen points each is a hundred and twenty thousand SVG
+ * coordinates the browser would keep as elements. Everything a reader points
+ * at, brushes or reads is still SVG or HTML over the top, so only the mass of
+ * lines is pixels — which is also why saving the figure keeps the axes and
+ * loses the lines, and why a site that needs a downloadable figure should say
+ * so before choosing this one.
+ */
+import type { ParallelAxisLayout } from './parallelAxes.ts';
+/** How strongly one kept line is drawn, so that the mass reads as a density. */
+export declare const PARALLEL_INCLUDED_ALPHA = 0.35;
+/** What one pass of the line painter needs. */
+export interface ParallelPaint {
+    /** The axes, from left to right, already placed and measured. */
+    layouts: readonly ParallelAxisLayout[];
+    /** Each axis's column, in the same order. */
+    values: ReadonlyArray<ArrayLike<number>>;
+    /** How many rows to draw. */
+    count: number;
+    /**
+     * Which rows the brushes keep, a zero meaning the row is drawn underneath in
+     * the excluded ink.
+     * @default null — every row is kept and nothing is drawn underneath
+     */
+    included?: Uint8Array | null;
+    /**
+     * Which colour each row takes, as a step into `palette`.
+     * @default null — every line takes `line`
+     */
+    steps?: Uint8Array | null;
+    /**
+     * The colours a step indexes, from `parallelPalette`.
+     * @default [] — nothing to index
+     */
+    palette?: readonly string[];
+    /** The ink a line takes when no quantity is colouring the lines. */
+    line: string;
+    /** The ink the rows a brush left out are drawn in. */
+    excluded: string;
+    /**
+     * How strongly a kept line is drawn. Turn it down for a dense library.
+     * @default PARALLEL_INCLUDED_ALPHA
+     */
+    includedAlpha?: number;
+}
+/** One row drawn over the mass, and the ink it is drawn in. */
+export interface ParallelHighlight {
+    /** The row. */
+    row: number;
+    /** Its ink. */
+    color: string;
+}
+/** What the highlight pass needs. */
+export interface ParallelHighlightPaint {
+    /** The rows to draw, the last one on top. */
+    highlights: readonly ParallelHighlight[];
+    /** The axes, from left to right. */
+    layouts: readonly ParallelAxisLayout[];
+    /** Each axis's column, in the same order. */
+    values: ReadonlyArray<ArrayLike<number>>;
+    /** The ink the halo under each line is drawn in. */
+    halo: string;
+}
+/**
+ * Resize a canvas to the device pixel grid and move its origin to the drawing
+ * area, which also clears whatever it held.
+ * @param canvas - The canvas, or `null` before it is mounted.
+ * @param width - Width of the figure, in CSS pixels.
+ * @param height - Its height, in CSS pixels.
+ * @returns The context, or `null` when there is nothing to draw on.
+ */
+export declare function preparePlotCanvas(canvas: HTMLCanvasElement | null, width: number, height: number): CanvasRenderingContext2D | null;
+/**
+ * Draw one line per row: the ones a brush left out first, underneath, then the
+ * kept ones over them.
+ *
+ * The excluded rows are one single path stroked once, in a light grey rather
+ * than a translucent black: overlapping segments of one stroked path
+ * accumulate alpha, so a translucent black saturates to black wherever the
+ * library is dense, while a light grey is a colour the pile can only converge
+ * on.
+ * @param context - A context already scaled and moved to the drawing area by {@link preparePlotCanvas}.
+ * @param paint - See {@link ParallelPaint}.
+ */
+export declare function paintParallelLines(context: CanvasRenderingContext2D, paint: ParallelPaint): void;
+/**
+ * Draw a few singled-out rows over the mass, each over a halo and dotted at
+ * every axis crossing.
+ * @param context - A context already scaled and moved to the drawing area.
+ * @param paint - See {@link ParallelHighlightPaint}.
+ */
+export declare function paintParallelHighlights(context: CanvasRenderingContext2D, paint: ParallelHighlightPaint): void;
+/**
+ * Add one row's line to the path being built.
+ *
+ * The line is one polyline per unbroken run of known values, so a row with a
+ * gap in the middle is drawn as two, and nothing is painted over an axis the
+ * row has no value on.
+ * @param context - A context already scaled and moved to the drawing area.
+ * @param row - The row to trace.
+ * @param layouts - The axes, from left to right.
+ * @param values - Each axis's column, in the same order.
+ */
+export declare function traceParallelRow(context: CanvasRenderingContext2D, row: number, layouts: readonly ParallelAxisLayout[], values: ReadonlyArray<ArrayLike<number>>): void;
+//# sourceMappingURL=parallelPaint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parallelPaint.d.ts","sourceRoot":"","sources":["../../../src/parallel/core/parallelPaint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAG5D,gFAAgF;AAChF,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAa5C,+CAA+C;AAC/C,MAAM,WAAW,aAAa;IAC5B,iEAAiE;IACjE,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACvC,6CAA6C;IAC7C,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;IACzC,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,QAAQ,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IAC7B;;;OAGG;IACH,KAAK,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IAC1B;;;OAGG;IACH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,+DAA+D;AAC/D,MAAM,WAAW,iBAAiB;IAChC,eAAe;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED,qCAAqC;AACrC,MAAM,WAAW,sBAAsB;IACrC,6CAA6C;IAC7C,UAAU,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACzC,oCAAoC;IACpC,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACvC,6CAA6C;IAC7C,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;IACzC,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,iBAAiB,GAAG,IAAI,EAChC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,wBAAwB,GAAG,IAAI,CAYjC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,wBAAwB,EACjC,KAAK,EAAE,aAAa,GACnB,IAAI,CAsCN;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,wBAAwB,EACjC,KAAK,EAAE,sBAAsB,GAC5B,IAAI,CA2BN;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,wBAAwB,EACjC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,SAAS,kBAAkB,EAAE,EACtC,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,GACvC,IAAI,CAsBN"}

package/lib/parallel/core/parallelPaint.js

@@ -0,0 +1,169 @@
+/**
+ * The lines, painted into a canvas.
+ *
+ * The first canvas figure in the family, and for one reason: ten thousand
+ * polylines of a dozen points each is a hundred and twenty thousand SVG
+ * coordinates the browser would keep as elements. Everything a reader points
+ * at, brushes or reads is still SVG or HTML over the top, so only the mass of
+ * lines is pixels — which is also why saving the figure keeps the axes and
+ * loses the lines, and why a site that needs a downloadable figure should say
+ * so before choosing this one.
+ */
+import { PARALLEL_MARGIN, parallelPixelAt } from "./parallelAxes.js";
+/** How strongly one kept line is drawn, so that the mass reads as a density. */
+export const PARALLEL_INCLUDED_ALPHA = 0.35;
+/** How wide a singled-out line's halo is, in pixels. */
+const HALO_WIDTH = 5;
+/** How wide a singled-out line itself is. */
+const HIGHLIGHT_WIDTH = 2;
+/** How large the dot at each of its axis crossings is. */
+const HIGHLIGHT_DOT_RADIUS = 3;
+const FULL_TURN = 2 * Math.PI;
+/**
+ * Resize a canvas to the device pixel grid and move its origin to the drawing
+ * area, which also clears whatever it held.
+ * @param canvas - The canvas, or `null` before it is mounted.
+ * @param width - Width of the figure, in CSS pixels.
+ * @param height - Its height, in CSS pixels.
+ * @returns The context, or `null` when there is nothing to draw on.
+ */
+export function preparePlotCanvas(canvas, width, height) {
+    if (canvas === null)
+        return null;
+    const context = canvas.getContext('2d');
+    if (context === null)
+        return null;
+    const pixelRatio = Math.max(globalThis.devicePixelRatio || 1, 1);
+    // Assigning the backing store is what clears it; there is no second clear.
+    canvas.width = Math.round(width * pixelRatio);
+    canvas.height = Math.round(height * pixelRatio);
+    context.resetTransform();
+    context.scale(pixelRatio, pixelRatio);
+    context.translate(PARALLEL_MARGIN.left, PARALLEL_MARGIN.top);
+    return context;
+}
+/**
+ * Draw one line per row: the ones a brush left out first, underneath, then the
+ * kept ones over them.
+ *
+ * The excluded rows are one single path stroked once, in a light grey rather
+ * than a translucent black: overlapping segments of one stroked path
+ * accumulate alpha, so a translucent black saturates to black wherever the
+ * library is dense, while a light grey is a colour the pile can only converge
+ * on.
+ * @param context - A context already scaled and moved to the drawing area by {@link preparePlotCanvas}.
+ * @param paint - See {@link ParallelPaint}.
+ */
+export function paintParallelLines(context, paint) {
+    const { layouts, values, count, line, excluded, includedAlpha } = paint;
+    if (layouts.length < 2)
+        return;
+    const included = paint.included ?? null;
+    const steps = paint.steps ?? null;
+    const palette = paint.palette ?? [];
+    context.lineWidth = 1;
+    if (included !== null) {
+        context.strokeStyle = excluded;
+        context.beginPath();
+        for (let row = 0; row < count; row++) {
+            if (included[row] !== 0)
+                continue;
+            traceParallelRow(context, row, layouts, values);
+        }
+        context.stroke();
+    }
+    context.globalAlpha = includedAlpha ?? PARALLEL_INCLUDED_ALPHA;
+    context.strokeStyle = line;
+    let previousStep = -1;
+    for (let row = 0; row < count; row++) {
+        if (included !== null && included[row] === 0)
+            continue;
+        if (steps !== null) {
+            const step = steps[row];
+            if (step !== previousStep) {
+                // A step past the end of the ramp is a quantity nobody knows for this
+                // row; it is drawn in the neutral ink rather than in the ramp's first
+                // colour, which means the smallest value in the set.
+                context.strokeStyle = palette[step] ?? line;
+                previousStep = step;
+            }
+        }
+        context.beginPath();
+        traceParallelRow(context, row, layouts, values);
+        context.stroke();
+    }
+    context.globalAlpha = 1;
+}
+/**
+ * Draw a few singled-out rows over the mass, each over a halo and dotted at
+ * every axis crossing.
+ * @param context - A context already scaled and moved to the drawing area.
+ * @param paint - See {@link ParallelHighlightPaint}.
+ */
+export function paintParallelHighlights(context, paint) {
+    const { highlights, layouts, values, halo } = paint;
+    if (layouts.length < 2)
+        return;
+    context.lineJoin = 'round';
+    context.lineCap = 'round';
+    for (const { row, color } of highlights) {
+        context.beginPath();
+        traceParallelRow(context, row, layouts, values);
+        context.strokeStyle = halo;
+        context.lineWidth = HALO_WIDTH;
+        context.stroke();
+        context.strokeStyle = color;
+        context.lineWidth = HIGHLIGHT_WIDTH;
+        context.stroke();
+        context.fillStyle = color;
+        for (let index = 0; index < layouts.length; index++) {
+            const layout = layouts[index];
+            const column = values[index];
+            if (layout === undefined || column === undefined)
+                continue;
+            const y = parallelPixelAt(layout.pixels, column[row]);
+            if (!Number.isFinite(y))
+                continue;
+            context.beginPath();
+            context.arc(layout.x, y, HIGHLIGHT_DOT_RADIUS, 0, FULL_TURN);
+            context.fill();
+        }
+    }
+}
+/**
+ * Add one row's line to the path being built.
+ *
+ * The line is one polyline per unbroken run of known values, so a row with a
+ * gap in the middle is drawn as two, and nothing is painted over an axis the
+ * row has no value on.
+ * @param context - A context already scaled and moved to the drawing area.
+ * @param row - The row to trace.
+ * @param layouts - The axes, from left to right.
+ * @param values - Each axis's column, in the same order.
+ */
+export function traceParallelRow(context, row, layouts, values) {
+    let started = false;
+    for (let index = 0; index < layouts.length; index++) {
+        const layout = layouts[index];
+        const column = values[index];
+        if (layout === undefined || column === undefined)
+            continue;
+        const y = parallelPixelAt(layout.pixels, column[row]);
+        // A row whose value on this axis is not known yet has no point to draw,
+        // and the line breaks rather than bridging the axis: a segment drawn
+        // across it reads as a value the row does not hold, and the hit test,
+        // which has no endpoint there, cannot pick it back.
+        if (!Number.isFinite(y)) {
+            started = false;
+            continue;
+        }
+        if (started) {
+            context.lineTo(layout.x, y);
+        }
+        else {
+            context.moveTo(layout.x, y);
+            started = true;
+        }
+    }
+}
+//# sourceMappingURL=parallelPaint.js.map

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

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

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

@@ -0,0 +1,40 @@
+/**
+ * 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 type { ColorScale } from '../../color/core/interpolate.ts';
+import type { ParallelColorBy } from './parallelTypes.ts';
+/** How many steps the ramp is quantised into; there is one more colour than steps. */
+export declare 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 declare const PARALLEL_PALETTE_UNKNOWN: number;
+/**
+ * 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 declare function parallelPalette(scale?: ColorScale | readonly string[]): readonly string[];
+/**
+ * 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 declare function parallelColorSteps(color: ParallelColorBy, count: number): Uint8Array;
+//# sourceMappingURL=parallelPalette.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parallelPalette.d.ts","sourceRoot":"","sources":["../../../src/parallel/core/parallelPalette.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAOlE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,sFAAsF;AACtF,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,QAA6B,CAAC;AAEnE;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,KAAK,CAAC,EAAE,UAAU,GAAG,SAAS,MAAM,EAAE,GACrC,SAAS,MAAM,EAAE,CAEnB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,eAAe,EACtB,KAAK,EAAE,MAAM,GACZ,UAAU,CAqBZ"}