@fundar/data-chart-telling 1.1.0 → 1.3.0

package/dist/phases/statistics/Statistics.js

@@ -6,6 +6,7 @@ import { Density2dStatistic } from './methods/Density2dStatistic';
 import { BoxStatistic } from './methods/BoxStatistic';
 import { RegressionStatistic } from './methods/RegressionStatistic';
 import { BollingerStatistic } from './methods/BollingerStatistic';
+import { DeviationStatistic } from './methods/DeviationStatistic';
 /**
  * The statistics a plot or a marker asks for, as the markers they draw as.
  * Each statistic type is a class of its own under `methods/`; the same
@@ -13,10 +14,11 @@ import { BollingerStatistic } from './methods/BollingerStatistic';
  */
 export class Statistics {
     /**
-     * Builds one {@link StatisticConfig} over a data source into the marker it
-     * renders as - `regression`/`bollinger` construct their marker directly
-     * (svelteplot resolves the curve/band itself, at render time); the others
-     * compute their rows first.
+     * Builds one {@link StatisticConfig} over a data source into the markers it
+     * renders as. Every statistic's own `build` returns a list, since one can
+     * draw several markers (`deviation`'s band and rule); `regression`/`bollinger`
+     * construct their marker directly (svelteplot resolves the curve/band
+     * itself, at render time), the others compute their rows first.
      */
     static buildMarker(source, config) {
         switch (config.type) {
@@ -32,6 +34,8 @@ export class Statistics {
                 return RegressionStatistic.build(source, config);
             case 'bollinger':
                 return BollingerStatistic.build(source, config);
+            case 'deviation':
+                return DeviationStatistic.build(source, config);
         }
     }
     /** Narrows a `Series`'s own `Accessor<T,AxisValue>` to a source's field-key-or-function shape - safe in practice, since a real row's field key is always a string. */
@@ -52,7 +56,7 @@ export class Statistics {
      * accessor). Named `series`: one statistic per listed series.
      */
     static buildForPlot(args) {
-        const { series, statistics, colorFor } = args;
+        const { series, statistics, valueAxis, colorFor } = args;
         if (!statistics?.length || !series.length)
             return [];
         return statistics.flatMap((stat) => {
@@ -62,9 +66,10 @@ export class Statistics {
                     data: pooled,
                     x: Statistics.#accessor(series[0].x),
                     y: Statistics.#accessor(series[0].y),
+                    axis: valueAxis,
                     color: colorFor?.(series[0].name)
                 };
-                return [Statistics.buildMarker(source, stat)];
+                return Statistics.buildMarker(source, stat);
             }
             const names = stat.series ?? series.map((s) => s.name);
             return names.flatMap((name) => {
@@ -75,9 +80,10 @@ export class Statistics {
                     data: match.data,
                     x: Statistics.#accessor(match.x),
                     y: Statistics.#accessor(match.y),
+                    axis: valueAxis,
                     color: colorFor?.(name)
                 };
-                return [Statistics.buildMarker(source, stat)];
+                return Statistics.buildMarker(source, stat);
             });
         });
     }
@@ -128,7 +134,7 @@ export class Statistics {
      * (neither field) always falls through the guard below untouched, and a
      * future "common" marker kind is eligible with no extra bookkeeping here.
      */
-    static expandMarkers(markers, fallbackData) {
+    static expandMarkers(markers, fallbackData, valueAxis) {
         return markers.flatMap((marker) => {
             const statable = marker;
             const { x, y } = statable;
@@ -137,7 +143,11 @@ export class Statistics {
             if (!statable.statistics?.length || !isAccessor(x) || !isAccessor(y))
                 return [marker];
             const data = statable.data ?? fallbackData;
-            const accessors = { x: x, y: y };
+            const accessors = {
+                x: x,
+                y: y,
+                axis: valueAxis
+            };
             // A marker's `color` channel groups it: each statistic is then derived per
             // group, in that group's own color - same as a plot's statistics per series.
             const colorFn = statable.color
@@ -146,7 +156,7 @@ export class Statistics {
             const flatColor = Statistics.#markerBaseColor(statable);
             const derived = statable.statistics.flatMap((stat) => {
                 if (!colorFn || !statable.color || stat.pooled) {
-                    return [Statistics.buildMarker({ data, ...accessors, color: flatColor }, stat)];
+                    return Statistics.buildMarker({ data, ...accessors, color: flatColor }, stat);
                 }
                 return Statistics.#groupRowsByColor(data, statable.color).flatMap((rows) => Statistics.buildMarker({ data: rows, ...accessors, color: colorFn(rows[0]) }, stat));
             });

package/dist/phases/statistics/StatisticsPhase.js

@@ -24,9 +24,17 @@ export class StatisticsPhase {
     run = (state) => {
         if (!state.panels)
             return { ...state, markers: this.#resolve(state) };
-        const markers = state.panels.flatMap((panel) => this.#resolve(FacetPanels.narrowToPanel(state, panel.key)).map((marker) => ({ ...marker, [PANEL_KEY]: panel.key })));
+        const markers = state.panels.flatMap((panel) => this.#resolve(this.#ownTo(FacetPanels.narrowToPanel(state, panel.key), panel.key)).map((marker) => ({ ...marker, [PANEL_KEY]: panel.key })));
         return { ...state, markers };
     };
+    /** `state` with the author's markers that the "facet" phase tagged for another panel left out. */
+    #ownTo(state, panel) {
+        const authorMarkers = state.authorMarkers?.filter((marker) => {
+            const tagged = marker[PANEL_KEY];
+            return tagged === undefined || tagged === panel;
+        });
+        return { ...state, authorMarkers };
+    }
     #resolve(state) {
         const options = this.#options;
         const { resolvedSeries = [], flat = [], colorForSeries, statistics, authorMarkers = [] } = state;
@@ -53,7 +61,12 @@ export class StatisticsPhase {
             ? (state.processedGroups ?? []).map((group) => group.series)
             : resolvedSeries;
         return [
-            ...Statistics.buildForPlot({ series: measured, statistics, colorFor: colorForSeries }),
+            ...Statistics.buildForPlot({
+                series: measured,
+                statistics,
+                valueAxis,
+                colorFor: colorForSeries
+            }),
             ...Statistics.expandMarkers(AuthorMarkers.prepare(positioned, {
                 grouping: inheritGrouping ? state.grouping : undefined,
                 color: inheritGrouping ? state.color : undefined,
@@ -61,7 +74,7 @@ export class StatisticsPhase {
                 flat,
                 resolvedSeries,
                 scopedGroups: state.scopedGroups
-            }), flat)
+            }), flat, valueAxis)
         ];
     }
 }

package/dist/phases/statistics/methods/BollingerStatistic.d.ts

@@ -5,5 +5,5 @@ import { type StatisticSource } from '../../../types/phases/statistics/source';
 export declare class BollingerStatistic {
     static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: Extract<StatisticConfig, {
         type: 'bollinger';
-    }>): BollingerMarkerConfig;
+    }>): BollingerMarkerConfig[];
 }

package/dist/phases/statistics/methods/BollingerStatistic.js

@@ -2,17 +2,19 @@ import { STATISTIC_FALLBACK_COLOR } from '../../../types/phases/statistics/sourc
 /** Bollinger bands over the source, drawn as a `bollinger` marker (svelteplot computes them at render time). */
 export class BollingerStatistic {
     static build(source, config) {
-        return {
-            type: 'bollinger',
-            data: source.data,
-            x: source.x,
-            y: source.y,
-            n: config.n,
-            k: config.k,
-            styles: {
-                ...config.styles,
-                stroke: config.styles?.stroke ?? source.color ?? STATISTIC_FALLBACK_COLOR
+        return [
+            {
+                type: 'bollinger',
+                data: source.data,
+                x: source.x,
+                y: source.y,
+                n: config.n,
+                k: config.k,
+                styles: {
+                    ...config.styles,
+                    stroke: config.styles?.stroke ?? source.color ?? STATISTIC_FALLBACK_COLOR
+                }
             }
-        };
+        ];
     }
 }

package/dist/phases/statistics/methods/BoxStatistic.d.ts

@@ -5,5 +5,5 @@ import { type StatisticSource } from '../../../types/phases/statistics/source';
 export declare class BoxStatistic {
     static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: Extract<StatisticConfig, {
         type: 'box';
-    }>): BoxMarkerConfig;
+    }>): BoxMarkerConfig[];
 }

package/dist/phases/statistics/methods/BoxStatistic.js

@@ -2,17 +2,19 @@ import { STATISTIC_FALLBACK_COLOR } from '../../../types/phases/statistics/sourc
 /** Box-and-whisker summary of the source, drawn as a `box` marker. */
 export class BoxStatistic {
     static build(source, config) {
-        return {
-            type: 'box',
-            data: source.data,
-            x: source.x,
-            y: source.y,
-            sort: config.sort,
-            bar: { fill: source.color ?? STATISTIC_FALLBACK_COLOR, ...config.bar },
-            rule: config.rule,
-            dot: config.dot,
-            tickMedian: config.tickMedian,
-            tickMinMax: config.tickMinMax
-        };
+        return [
+            {
+                type: 'box',
+                data: source.data,
+                x: source.x,
+                y: source.y,
+                sort: config.sort,
+                bar: { fill: source.color ?? STATISTIC_FALLBACK_COLOR, ...config.bar },
+                rule: config.rule,
+                dot: config.dot,
+                tickMedian: config.tickMedian,
+                tickMinMax: config.tickMinMax
+            }
+        ];
     }
 }

package/dist/phases/statistics/methods/Density2dStatistic.d.ts

@@ -5,5 +5,5 @@ import { type StatisticSource } from '../../../types/phases/statistics/source';
 export declare class Density2dStatistic {
     static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: Extract<StatisticConfig, {
         type: 'density2d';
-    }>): DensityMarkerConfig;
+    }>): DensityMarkerConfig[];
 }

package/dist/phases/statistics/methods/Density2dStatistic.js

@@ -2,17 +2,19 @@ import { STATISTIC_FALLBACK_COLOR } from '../../../types/phases/statistics/sourc
 /** 2D kernel density over the source's `x` and `y`, drawn as a `density` marker. */
 export class Density2dStatistic {
     static build(source, config) {
-        return {
-            type: 'density',
-            data: source.data,
-            x: source.x,
-            y: source.y,
-            bandwidth: config.bandwidth,
-            thresholds: config.thresholds,
-            styles: {
-                ...config.styles,
-                stroke: config.styles?.stroke ?? source.color ?? STATISTIC_FALLBACK_COLOR
+        return [
+            {
+                type: 'density',
+                data: source.data,
+                x: source.x,
+                y: source.y,
+                bandwidth: config.bandwidth,
+                thresholds: config.thresholds,
+                styles: {
+                    ...config.styles,
+                    stroke: config.styles?.stroke ?? source.color ?? STATISTIC_FALLBACK_COLOR
+                }
             }
-        };
+        ];
     }
 }

package/dist/phases/statistics/methods/DensityStatistic.d.ts

@@ -8,5 +8,5 @@ export declare class DensityStatistic {
      * `x` is the value and `y` the density, so it draws on the plot's axes as-is.
      * The output is one derived row per estimate point rather than one per input row.
      */
-    static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: DensityStatisticOptions): AreaMarkerConfig;
+    static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: DensityStatisticOptions): AreaMarkerConfig[];
 }

package/dist/phases/statistics/methods/DensityStatistic.js

@@ -15,15 +15,17 @@ export class DensityStatistic {
             kernel: config.kernel,
             bandwidth: config.bandwidth
         });
-        return {
-            type: 'area',
-            data: result.data,
-            x: result.x,
-            y: result.y,
-            styles: {
-                ...config.styles,
-                fill: config.styles?.fill ?? source.color ?? STATISTIC_FALLBACK_COLOR
+        return [
+            {
+                type: 'area',
+                data: result.data,
+                x: result.x,
+                y: result.y,
+                styles: {
+                    ...config.styles,
+                    fill: config.styles?.fill ?? source.color ?? STATISTIC_FALLBACK_COLOR
+                }
             }
-        };
+        ];
     }
 }

package/dist/phases/statistics/methods/DeviationStatistic.d.ts

@@ -0,0 +1,8 @@
+import type { DeviationStatisticOptions } from '../../../types/layout/statistics';
+import type { AxisBasedMarkersConfig } from '../../../types/markers/common';
+import { type StatisticSource } from '../../../types/phases/statistics/source';
+/** An estimator of the source's values along the plot's value axis and a band around it, drawn as a `rect` and a `rule` marker, each optionally labelled by a `text` marker. */
+export declare class DeviationStatistic {
+    #private;
+    static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: DeviationStatisticOptions): AxisBasedMarkersConfig[];
+}

package/dist/phases/statistics/methods/DeviationStatistic.js

@@ -0,0 +1,111 @@
+import { deviation, extent, mean, median } from 'd3-array';
+import { resolveAccessor } from '../../../utils/accessors';
+import { STATISTIC_FALLBACK_COLOR } from '../../../types/phases/statistics/source';
+/** Scales a median absolute deviation to the standard deviation of a normal distribution. */
+const MAD_SCALE = 1.4826;
+const DEFAULT_BAND_OPACITY = 0.15;
+const LABEL_FONT_SIZE = 10;
+/** Pixels between a label and the line it names, and between it and the plot's edge. */
+const LABEL_GAP = 4;
+/** An estimator of the source's values along the plot's value axis and a band around it, drawn as a `rect` and a `rule` marker, each optionally labelled by a `text` marker. */
+export class DeviationStatistic {
+    static build(source, config) {
+        const axis = source.axis ?? 'y';
+        const read = resolveAccessor(source[axis]);
+        const values = source.data
+            .map((d) => {
+            const v = read(d);
+            return v instanceof Date ? v.getTime() : typeof v === 'number' ? v : NaN;
+        })
+            .filter(Number.isFinite);
+        if (!values.length)
+            return [];
+        const center = DeviationStatistic.#estimate(values, config.estimator ?? 'mean');
+        const spread = DeviationStatistic.#spread(values, config.spread ?? 'stdev');
+        const half = (config.k ?? 1) * spread;
+        const color = source.color ?? STATISTIC_FALLBACK_COLOR;
+        const markers = [];
+        if (config.band !== false) {
+            const { label, ...style } = config.band ?? {};
+            const [lo, hi] = [center - half, center + half];
+            markers.push({
+                type: 'rect',
+                data: [{ lo, hi }],
+                ...(axis === 'x' ? { x1: 'lo', x2: 'hi' } : { y1: 'lo', y2: 'hi' }),
+                styles: { fillOpacity: DEFAULT_BAND_OPACITY, ...style, fill: style.fill ?? color }
+            });
+            if (label) {
+                const own = label === true ? {} : label;
+                const lower = own.edge === 'lower';
+                const outside = own.position === 'outside';
+                markers.push(DeviationStatistic.#label(axis, lower ? lo : hi, color, lower === outside, {
+                    text: own.text ?? (config.spread === 'mad' ? 'MAD' : 'STDEV'),
+                    styles: own.styles
+                }));
+            }
+        }
+        if (config.rule !== false) {
+            const { label, ...style } = config.rule ?? {};
+            markers.push({
+                type: 'rule',
+                axis,
+                value: center,
+                styles: { ...style, stroke: style.stroke ?? color }
+            });
+            if (label) {
+                const own = label === true ? {} : label;
+                markers.push(DeviationStatistic.#label(axis, center, color, axis === 'x', {
+                    text: own.text ?? (config.estimator ?? 'mean').toUpperCase(),
+                    styles: own.styles
+                }));
+            }
+        }
+        return markers;
+    }
+    /**
+     * A label beside the line at `position`, against the plot's start edge: a
+     * vertical line's reads down from the top, a horizontal line's ends at the
+     * right. `towardLower` puts its body on the side of lower values (left of a
+     * vertical line, below a horizontal one).
+     */
+    static #label(axis, position, color, towardLower, label) {
+        const vertical = axis === 'x';
+        const fontSize = label.styles?.fontSize ?? LABEL_FONT_SIZE;
+        const sign = towardLower ? -1 : 1;
+        // A vertical line's text is centred on its own point, so its half-height plus the gap clears the line.
+        const gap = LABEL_GAP + (vertical ? fontSize / 2 : 0);
+        const [dx, dy] = vertical ? [sign * gap, LABEL_GAP] : [-LABEL_GAP, -sign * gap];
+        return {
+            type: 'text',
+            text: label.text,
+            ...(vertical ? { x: position } : { y: position }),
+            frameAnchor: vertical ? 'top' : 'right',
+            styles: {
+                fill: color,
+                fontSize,
+                ...(vertical
+                    ? { rotate: 90, textAnchor: 'start', lineAnchor: 'middle' }
+                    : { textAnchor: 'end', lineAnchor: towardLower ? 'top' : 'bottom' }),
+                ...label.styles,
+                dx: dx + (label.styles?.dx ?? 0),
+                dy: dy + (label.styles?.dy ?? 0)
+            }
+        };
+    }
+    static #estimate(values, estimator) {
+        if (estimator === 'median')
+            return median(values);
+        if (estimator === 'midrange') {
+            const [lo, hi] = extent(values);
+            return (lo + hi) / 2;
+        }
+        return mean(values);
+    }
+    static #spread(values, spread) {
+        if (spread === 'mad') {
+            const mid = median(values);
+            return MAD_SCALE * median(values.map((v) => Math.abs(v - mid)));
+        }
+        return deviation(values) ?? 0;
+    }
+}

package/dist/phases/statistics/methods/MovingAverageStatistic.d.ts

@@ -8,5 +8,5 @@ export declare class MovingAverageStatistic {
      * no dedicated mark for this (unlike `regression`/`bollinger`). `windowY`
      * keeps one output row per input row, so `x` passes straight through.
      */
-    static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: MovingAverageStatisticOptions): LineMarkerConfig;
+    static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: MovingAverageStatisticOptions): LineMarkerConfig[];
 }

package/dist/phases/statistics/methods/MovingAverageStatistic.js

@@ -16,15 +16,17 @@ export class MovingAverageStatistic {
             k: config.k,
             reduce: config.reduce ?? 'mean'
         });
-        return {
-            type: 'line',
-            data: result.data,
-            x: result.x,
-            y: result.y,
-            styles: {
-                ...config.styles,
-                stroke: config.styles?.stroke ?? source.color ?? STATISTIC_FALLBACK_COLOR
+        return [
+            {
+                type: 'line',
+                data: result.data,
+                x: result.x,
+                y: result.y,
+                styles: {
+                    ...config.styles,
+                    stroke: config.styles?.stroke ?? source.color ?? STATISTIC_FALLBACK_COLOR
+                }
             }
-        };
+        ];
     }
 }

package/dist/phases/statistics/methods/RegressionStatistic.d.ts

@@ -5,5 +5,5 @@ import { type StatisticSource } from '../../../types/phases/statistics/source';
 export declare class RegressionStatistic {
     static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: Extract<StatisticConfig, {
         type: 'regression';
-    }>): RegressionMarkerConfig;
+    }>): RegressionMarkerConfig[];
 }

package/dist/phases/statistics/methods/RegressionStatistic.js

@@ -2,20 +2,22 @@ import { STATISTIC_FALLBACK_COLOR } from '../../../types/phases/statistics/sourc
 /** A regression curve over the source, drawn as a `regression` marker (svelteplot fits it at render time). */
 export class RegressionStatistic {
     static build(source, config) {
-        return {
-            type: 'regression',
-            data: source.data,
-            x: source.x,
-            y: source.y,
-            regressionType: config.regressionType,
-            order: config.order,
-            base: config.base,
-            span: config.span,
-            confidence: config.confidence,
-            styles: {
-                ...config.styles,
-                stroke: config.styles?.stroke ?? source.color ?? STATISTIC_FALLBACK_COLOR
+        return [
+            {
+                type: 'regression',
+                data: source.data,
+                x: source.x,
+                y: source.y,
+                regressionType: config.regressionType,
+                order: config.order,
+                base: config.base,
+                span: config.span,
+                confidence: config.confidence,
+                styles: {
+                    ...config.styles,
+                    stroke: config.styles?.stroke ?? source.color ?? STATISTIC_FALLBACK_COLOR
+                }
             }
-        };
+        ];
     }
 }

package/dist/phases/transforms/ProcessedPositions.js

@@ -1,4 +1,4 @@
-import { resolveAccessor } from '../../plots/utils/accessors';
+import { resolveAccessor } from '../../utils/accessors';
 import { isGapValue } from '../../plots/utils/gaps';
 const POSITION_CHANNELS = {
     x: ['x', 'x1', 'x2'],

package/dist/phases/transforms/TransformsPhase.js

@@ -1,7 +1,9 @@
 import { Transforms } from './Transforms';
+import { ValueSelection } from './ValueSelection';
+import { ProcessedPositions } from './ProcessedPositions';
 import { seriesIdOf } from '../../utils/grouping';
 import { PANEL_KEY } from '../facet/FacetPanels';
-import { resolveAccessor } from '../../plots/utils/accessors';
+import { resolveAccessor } from '../../utils/accessors';
 import { buildGroupedSeries } from '../../plots/utils/segments';
 import { PlotAxes } from '../data/PlotAxes';
 /** The field each processed row carries its series name under, for its color, legend and labels. */
@@ -94,12 +96,56 @@ export class TransformsPhase {
         };
         return this.#withGroups({ ...state, processedData });
     };
-    /** `state` with its processed rows split into the visual groups the kind's marks draw (`processedGroups`). */
+    /**
+     * `state` with its processed rows split into the visual groups the kind's marks
+     * draw (`processedGroups`), and the rows its value labels are written for
+     * (`labelled`).
+     */
     #withGroups(state) {
         const processedGroups = this.#options.groups === 'runs'
             ? TransformsPhase.#buildRuns(state)
             : TransformsPhase.#buildGroups(state, this.#connect);
-        return { ...state, processedGroups };
+        return { ...state, processedGroups, ...this.#labelled(state) };
+    }
+    /**
+     * The rows `styles.values` writes labels for, picked per facet panel - a
+     * panel's own last row, not the last of every panel - by the author's
+     * `select` and `series`, over the plot's own default. Left out while the
+     * labels are off, or when the plot picks no rows.
+     */
+    #labelled(state) {
+        const options = this.#options.labels;
+        const values = state.values;
+        if (!options || !(values?.show ?? options.show))
+            return {};
+        const processed = state.processedData;
+        const valueAxis = PlotAxes.valueOf(state);
+        const select = values?.select ?? options.select;
+        const selections = ValueSelection.transforms(select, values?.series, valueAxis);
+        const position = ProcessedPositions.of(processed, valueAxis);
+        const skip = options.skip?.(state);
+        const channels = {
+            x: position.x,
+            y: position.y,
+            group: options.group === 'category'
+                ? position[PlotAxes.categoryOf(state)]
+                : SERIES_ID_KEY
+        };
+        const panels = new Map();
+        for (const row of processed.data) {
+            if (skip?.(row))
+                continue;
+            const bucket = panels.get(row[PANEL_KEY]);
+            if (bucket)
+                bucket.push(row);
+            else
+                panels.set(row[PANEL_KEY], [row]);
+        }
+        const labelled = new Set([...panels.values()].flatMap((rows) => ValueSelection.pick(rows, selections, channels)));
+        return {
+            labelled: processed.data.filter((row) => labelled.has(row)),
+            labelSelects: ValueSelection.selectors(select)
+        };
     }
     /** What a gap-filled row carries: its interpolated value and the kind of zone that filled it. */
     static #fillTags(fill) {

package/dist/phases/transforms/ValueSelection.d.ts

@@ -0,0 +1,30 @@
+import type { ValueSelect } from '../../types/layout/styles';
+import type { MarkerTransform } from '../../types/transforms';
+import type { ProcessedRow } from '../../types/phases';
+/**
+ * Which rows of a plot a value label is written for: `styles.values.select`
+ * (or the plot's own default) and `series`, run as `filter` and `select`
+ * transforms over the processed rows. The labelled rows are the union of what
+ * each selector picks, returned as the rows themselves, in their own order.
+ */
+export declare class ValueSelection {
+    /** `select` as a list: none is every row. */
+    static selectors(select: ValueSelect | ValueSelect[] | undefined): ValueSelect[];
+    /**
+     * The transforms that pick the rows, one list per selector: the series filter,
+     * then the `select` of that selector, with `'min'` and `'max'` read on
+     * `valueAxis`. Without selectors, one list that only filters the series.
+     */
+    static transforms(select: ValueSelect | ValueSelect[] | undefined, series: string | string[] | undefined, valueAxis: 'x' | 'y'): MarkerTransform[][];
+    /**
+     * The rows of `rows` that any of `selections` picks, grouped by `group`
+     * (a field key or accessor) and compared on `x` and `y` - the value axis'
+     * channel is what `'min'` and `'max'` read. A transform returns copies of its
+     * rows, so each is traced back to the row it came from.
+     */
+    static pick(rows: ProcessedRow[], selections: MarkerTransform[][], channels: {
+        x: unknown;
+        y: unknown;
+        group: unknown;
+    }): ProcessedRow[];
+}