@fundar/data-chart-telling 1.0.0 → 1.2.0

package/dist/phases/mapping/MappingPhase.js

@@ -1,10 +1,9 @@
-import { resolveAccessor } from '../../plots/utils/accessors';
-import { DataPhase } from '../data/DataPhase';
+import { resolveAccessor } from '../../utils/accessors';
 /**
  * The "mapping" phase every axis-based plot shares: every channel resolved to
  * a row accessor. `x`/`y` (and `color`) read the first series' own, falling
  * back to the plot's props; `grouping` is the key the "data" phase split rows
- * by ({@link DataPhase.buildGrouping}); any other channel resolves only when
+ * by (its `seriesGrouping`); any other channel resolves only when
  * its prop is set, and a size channel given a number stays that literal size.
  * An unset `x`/`y` reads each row itself, with no `source`.
  */
@@ -17,12 +16,11 @@ export class MappingPhase {
     run = (state, ctx) => {
         const first = state.resolvedSeries?.[0];
         const identity = { accessor: (d) => d };
-        const grouping = DataPhase.buildGrouping(state);
         const size = (value) => typeof value === 'number' ? value : MappingPhase.#channel(value);
         const channels = {
             x: MappingPhase.#channel(first?.x ?? state.x) ?? identity,
             y: MappingPhase.#channel(first?.y ?? state.y) ?? identity,
-            grouping: MappingPhase.#channel(grouping),
+            grouping: MappingPhase.#channel(state.seriesGrouping),
             color: MappingPhase.#channel(first?.color ?? state.color),
             opacity: MappingPhase.#channel(state.opacity),
             symbol: MappingPhase.#channel(state.symbol),

package/dist/phases/markers/MarkersPhase.js

@@ -1,3 +1,4 @@
+import { MarkerChannels } from '../../markers/utils/MarkerChannels';
 /**
  * The shared "markers" phase: everything the plot draws, bottom to top - the
  * plot kind's own marks, then what the "statistics" phase left in
@@ -21,7 +22,7 @@ export class MarkersPhase {
             : [];
         return {
             ...state,
-            markers: [...options.marks(state, ctx), ...(state.markers ?? []), ...valueLabels]
+            markers: MarkerChannels.inheritPosition(MarkerChannels.inheritAll([...options.marks(state, ctx), ...(state.markers ?? []), ...valueLabels], state.scales), state.processedData)
         };
     };
 }

package/dist/phases/scales/CategoryOrder.d.ts

@@ -0,0 +1,23 @@
+import { PlotAxes } from '../data/PlotAxes';
+import { type IntervalAccessors } from '../../plots/utils/RowNumbers';
+import type { AxisChannelName } from '../../types/layout/mapping';
+import type { CategorySort } from '../../types/layout/scales';
+import type { ProcessedData } from '../../types/phases';
+/**
+ * The order of a plot's categories under a declarative `scales.*.sort`: read off
+ * the processed rows, by what each category holds on the value axis - its value
+ * in a series, the sum of its values, or the spread between its lowest and its
+ * highest.
+ */
+export declare class CategoryOrder {
+    /** Whether a `sort` is a {@link CategorySort} rather than a comparator. */
+    static isDeclarative(sort: unknown): sort is CategorySort;
+    /**
+     * The categories of `axis`, in the order `sort` gives them; `undefined` without rows to
+     * read. The state is whatever has the processed rows and the axes.
+     */
+    static of(sort: CategorySort, state: {
+        processedData?: ProcessedData;
+        axes?: PlotAxes;
+    } & IntervalAccessors, axis: AxisChannelName): unknown[] | undefined;
+}

package/dist/phases/scales/CategoryOrder.js

@@ -0,0 +1,73 @@
+import { ProcessedPositions } from '../transforms/ProcessedPositions';
+import { SERIES_KEY } from '../transforms/TransformsPhase';
+import { PlotAxes } from '../data/PlotAxes';
+import { RowNumbers } from '../../plots/utils/RowNumbers';
+import { isGapValue } from '../../plots/utils/gaps';
+/**
+ * The order of a plot's categories under a declarative `scales.*.sort`: read off
+ * the processed rows, by what each category holds on the value axis - its value
+ * in a series, the sum of its values, or the spread between its lowest and its
+ * highest.
+ */
+export class CategoryOrder {
+    /** Whether a `sort` is a {@link CategorySort} rather than a comparator. */
+    static isDeclarative(sort) {
+        return typeof sort === 'object' && sort !== null && 'by' in sort;
+    }
+    /**
+     * The categories of `axis`, in the order `sort` gives them; `undefined` without rows to
+     * read. The state is whatever has the processed rows and the axes.
+     */
+    static of(sort, state, axis) {
+        const processed = state.processedData;
+        if (!processed)
+            return undefined;
+        const valueAxis = PlotAxes.valueOf(state);
+        const position = ProcessedPositions.of(processed, valueAxis);
+        const categoryOf = position[axis];
+        const valueOf = position[valueAxis];
+        // Each category, in the order the rows give them, with the values it holds.
+        const held = new Map();
+        for (const row of processed.data) {
+            const category = categoryOf(row);
+            const key = String(category);
+            let entry = held.get(key);
+            if (!entry)
+                held.set(key, (entry = { category, series: String(row[SERIES_KEY]), values: [], own: [] }));
+            const raw = valueOf(row);
+            const value = Number(raw);
+            if (isGapValue(raw) || !Number.isFinite(value))
+                continue;
+            entry.values.push(...RowNumbers.interval(state, row, value));
+            if (sort.series === undefined || String(row[SERIES_KEY]) === sort.series) {
+                entry.own.push(value);
+            }
+        }
+        const keyOf = (entry) => {
+            if (sort.by === 'range') {
+                return entry.values.length === 0
+                    ? undefined
+                    : Math.max(...entry.values) - Math.min(...entry.values);
+            }
+            return entry.own.length === 0 ? undefined : entry.own.reduce((sum, v) => sum + v, 0);
+        };
+        const sign = sort.order === 'descending' ? -1 : 1;
+        const sorted = (entries) => entries
+            .map((entry, index) => ({ entry, index, key: keyOf(entry) }))
+            .sort((a, b) => {
+            if (a.key === undefined || b.key === undefined) {
+                return ((a.key === undefined ? 1 : 0) - (b.key === undefined ? 1 : 0) || a.index - b.index);
+            }
+            return sign * (a.key - b.key) || a.index - b.index;
+        })
+            .map(({ entry }) => entry);
+        const entries = [...held.values()];
+        if (!sort.grouped)
+            return sorted(entries).map((entry) => entry.category);
+        const bySeries = new Map();
+        for (const entry of entries) {
+            bySeries.set(entry.series, [...(bySeries.get(entry.series) ?? []), entry]);
+        }
+        return [...bySeries.values()].flatMap((group) => sorted(group).map((entry) => entry.category));
+    }
+}

package/dist/phases/scales/ScalesPhase.d.ts

@@ -1,6 +1,6 @@
 import { PlotAxes } from '../data/PlotAxes';
 import type { AxisChannelName } from '../../types/layout/mapping';
-import type { AxisPlotState, AxisPlotCtx, PhaseStage, ProcessedData, ScalesStageOptions } from '../../types/phases';
+import type { AxisPlotState, AxisPlotCtx, PhaseStage, ScalesStageOptions } from '../../types/phases';
 type AnyAxisState = AxisPlotState<any, any, any, any>;
 /**
  * The shared "scales" phase. Each axis the kind lays out as categories
@@ -25,7 +25,5 @@ export declare class ScalesPhase<TState extends AnyAxisState, TCtx extends AxisP
     /** Whether the kind keeps its categories in the order the data gives them. */
     get keepsDataOrder(): boolean;
     run: (state: TState, ctx: TCtx) => TState;
-    /** Every value the plot's own processed rows sit at on one axis. */
-    static processedValues(processed: ProcessedData | undefined, axis: AxisChannelName): unknown[];
 }
 export {};

package/dist/phases/scales/ScalesPhase.js

@@ -1,7 +1,9 @@
-import { resolveAccessor } from '../../plots/utils/accessors';
+import { ProcessedPositions } from '../transforms/ProcessedPositions';
 import { isGapValue } from '../../plots/utils/gaps';
 import { MarkerAxisValues } from './MarkerAxisValues';
 import { PlotAxes } from '../data/PlotAxes';
+import { CategoryOrder } from './CategoryOrder';
+import { NiceTicks } from '../../layout/scales/NiceTicks';
 import { DISCRETE_SCALE_TYPES } from '../../types/layout/scales';
 const AXES = ['x', 'y'];
 const POSITION_CHANNELS = {
@@ -52,7 +54,7 @@ export class ScalesPhase {
         for (const axis of AXES) {
             const own = ScalesPhase.#defaultsOf(defaults, axis, axes);
             if (axes?.bands.includes(axis)) {
-                scales[axis] = this.#band(scales[axis], own, processedData, axis);
+                scales[axis] = this.#band(scales[axis], own, state, axis);
                 continue;
             }
             // The value axis of a plot with categories is never one itself, whatever it was marked as.
@@ -71,9 +73,14 @@ export class ScalesPhase {
             }
         }
         const fitted = options.fit?.({ ...state, scales }, ctx) ?? {};
+        const fittedAxes = [];
         for (const axis of AXES) {
-            if (fitted[axis])
-                scales[axis] = { ...scales[axis], ...fitted[axis] };
+            if (!fitted[axis])
+                continue;
+            const { fitted: ownDomain, ...fit } = fitted[axis];
+            scales[axis] = { ...scales[axis], ...fit };
+            if (ownDomain)
+                fittedAxes.push(axis);
         }
         for (const axis of AXES) {
             if (axes?.bands.includes(axis) || scales[axis]?.domain)
@@ -86,24 +93,32 @@ export class ScalesPhase {
             const aggregated = (processedData?.transforms.length ?? 0) > 0 && zero.has(axis);
             if (!derived.length && !ranged && !aggregated)
                 continue;
-            const own = numeric(ScalesPhase.processedValues(processedData, axis));
+            const own = numeric(ProcessedPositions.values(processedData, axis));
             if (!own)
                 continue;
             const values = [...own, ...derived, ...(zero.has(axis) ? [0] : [])];
-            scales[axis] = {
-                ...scales[axis],
-                domain: [Math.min(...values), Math.max(...values)],
-                nice: scales[axis]?.nice ?? true
-            };
+            const lo = Math.min(...values);
+            const hi = Math.max(...values);
+            const author = scales[axis];
+            // Niced here, with a tolerance, so parts that add up to a whole land on its tick.
+            const niced = author?.nice !== false && author?.ticks == null && hi > lo;
+            scales[axis] = niced
+                ? {
+                    ...author,
+                    domain: NiceTicks.fit(state, axis, lo, hi, NiceTicks.toleranceOf(author?.nice)),
+                    nice: false
+                }
+                : { ...author, domain: [lo, hi], nice: author?.nice ?? true };
         }
-        const next = { ...state, scales };
+        const next = { ...state, scales, ...(fittedAxes.length ? { fittedAxes } : {}) };
         return options.extend ? options.extend(next, ctx) : next;
     };
     /** A category axis as a band scale: the kind's options under the author's, in the order the kind asks for. */
-    #band(author, own, processed, axis) {
+    #band(author, own, state, axis) {
+        const processed = state.processedData;
         const given = author ?? {};
         const type = given.type === undefined || given.type === 'auto' || given.type === 'categorical'
-            ? 'band'
+            ? (own.type ?? 'band')
             : given.type;
         const band = { ...own, ...given, type };
         // A padding the author gives replaces the kind's own inner and outer ones.
@@ -115,23 +130,18 @@ export class ScalesPhase {
                 band.paddingOuter = given.padding;
             }
         }
+        // A sort by what the categories hold is read here, off the rows; the axis then draws from its domain.
+        if (CategoryOrder.isDeclarative(band.sort)) {
+            const order = band.domain ? undefined : CategoryOrder.of(band.sort, state, axis);
+            delete band.sort;
+            if (order)
+                band.domain = order;
+        }
         if (this.keepsDataOrder && !band.domain) {
-            band.domain = [...new Set(ScalesPhase.processedValues(processed, axis))];
+            band.domain = [...new Set(ProcessedPositions.values(processed, axis))];
         }
         return band;
     }
-    /** Every value the plot's own processed rows sit at on one axis. */
-    static processedValues(processed, axis) {
-        if (!processed)
-            return [];
-        return POSITION_CHANNELS[axis].flatMap((name) => {
-            const channel = processed.channels[name];
-            if (channel === undefined)
-                return [];
-            const read = resolveAccessor(channel);
-            return processed.data.map((row) => read(row));
-        });
-    }
     /** The axes `refs` name, by name or by the role they play in this state. */
     static #axesOf(refs, state) {
         return (refs ?? []).map((ref) => ref === 'value'
@@ -147,7 +157,7 @@ export class ScalesPhase {
     }
     /** How far an axis reaches from zero: the largest magnitude its rows, and the gaps filled in between them, sit at. */
     static #reachOf(state, axis) {
-        const rows = ScalesPhase.processedValues(state.processedData, axis)
+        const rows = ProcessedPositions.values(state.processedData, axis)
             .filter((v) => !isGapValue(v))
             .map((v) => Math.abs(Number(v)));
         const filled = [...(state.gapFillMaps?.values() ?? [])].flatMap((fills) => [...fills.values()].map((fill) => Math.abs(fill.value)));

package/dist/phases/sharedScales/SharedScalesPhase.d.ts

@@ -2,7 +2,7 @@ import { ScalesPhase } from '../scales/ScalesPhase';
 import type { PlotAxes } from '../data/PlotAxes';
 import type { AxisChannelName } from '../../types/layout/mapping';
 import type { FacetStageState, PhaseStage, ProcessedData, SharedAxisValues, SharedScalesOptions } from '../../types/phases';
-import type { AxisBasedScalesConfig } from '../../types/layout/scales';
+import type { AxisBasedScalesConfig, NiceOption } from '../../types/layout/scales';
 /** One channel's shared scale: its domain, and whether svelteplot may still round it. */
 type SharedScale = {
     domain: unknown[];
@@ -13,6 +13,10 @@ type SharedScalesState = FacetStageState & {
     axes?: PlotAxes;
     processedData?: ProcessedData;
     markers?: object[];
+    scales?: Partial<Record<AxisChannelName, {
+        nice?: NiceOption;
+        sort?: unknown;
+    }>>;
     sharedScales?: Record<string, AxisBasedScalesConfig<never>>;
 };
 /**
@@ -38,7 +42,7 @@ export declare class SharedScalesPhase<TState extends SharedScalesState, TCtx> i
      * count derived from each panel's height, which over-rounds short panels and
      * can disagree between panels of different heights.
      */
-    static buildSharedAxisScale(slices: SharedAxisValues[], axis: AxisChannelName): SharedScale;
+    static buildSharedAxisScale(slices: SharedAxisValues[], axis: AxisChannelName, niceTolerance?: number): SharedScale;
     /**
      * Where one panel's rows and markers sit on each axis, read off a pipeline
      * run over every panel - or, without a `panel`, where all of them sit.

package/dist/phases/sharedScales/SharedScalesPhase.js

@@ -1,7 +1,9 @@
-import { nice as niceExtent } from 'd3-array';
+import { ProcessedPositions } from '../transforms/ProcessedPositions';
+import { NiceTicks } from '../../layout/scales/NiceTicks';
+import { CategoryOrder } from '../scales/CategoryOrder';
 import { ScalesPhase } from '../scales/ScalesPhase';
 import { Pipeline } from '../Pipeline';
-import { PANEL_KEY, FacetPhase } from '../facet/FacetPhase';
+import { PANEL_KEY, FacetPanels } from '../facet/FacetPanels';
 import { isFacetWrap } from '../../layout/facet/config';
 import { MarkerAxisValues } from '../scales/MarkerAxisValues';
 /** Natural ascending order, as svelteplot sorts a band domain. */
@@ -38,7 +40,9 @@ export class SharedScalesPhase {
         // A symmetric axis has no domain but the one the kind's "scales" phase gives it.
         const fromPhase = new Set([
             ...(this.#options?.fromScalesPhase ?? []),
-            ...this.#scales.symmetricAxes(state)
+            ...this.#scales.symmetricAxes(state),
+            // A category axis ordered by what its categories hold takes the order the "scales" phase reads off every row.
+            ...(state.axes?.bands ?? []).filter((axis) => CategoryOrder.isDeclarative(state.scales?.[axis]?.sort))
         ]);
         const layout = {
             band: [...(state.axes?.bands ?? [])],
@@ -49,7 +53,7 @@ export class SharedScalesPhase {
         /** The channel's domain over `members` panels, or every row without them. */
         const domainOver = (channel, members) => {
             if (fromPhase.has(channel)) {
-                const scoped = members ? FacetPhase.narrowToPanels(state, members) : state;
+                const scoped = members ? FacetPanels.narrowToPanels(state, members) : state;
                 const scales = this.#kindScales.run(scoped, ctx).scales;
                 const domain = scales?.[channel]?.domain;
                 return domain === undefined ? undefined : { domain };
@@ -59,7 +63,7 @@ export class SharedScalesPhase {
             const values = members
                 ? members.map((panel) => SharedScalesPhase.buildPanelAxisValues(state, panel, layout))
                 : [SharedScalesPhase.buildPanelAxisValues(state, undefined, layout)];
-            return SharedScalesPhase.buildSharedAxisScale(values, channel);
+            return SharedScalesPhase.buildSharedAxisScale(values, channel, NiceTicks.toleranceOf(state.scales?.[channel]?.nice));
         };
         const cache = new Map();
         const scalesOf = (place) => {
@@ -103,7 +107,7 @@ export class SharedScalesPhase {
      * count derived from each panel's height, which over-rounds short panels and
      * can disagree between panels of different heights.
      */
-    static buildSharedAxisScale(slices, axis) {
+    static buildSharedAxisScale(slices, axis, niceTolerance) {
         const values = slices
             .flatMap((slice) => slice[axis])
             .filter((v) => v != null && v !== '' && !(typeof v === 'number' && !Number.isFinite(v)));
@@ -119,7 +123,9 @@ export class SharedScalesPhase {
             const numbers = slices.some((slice) => slice.zero.includes(axis))
                 ? [...values, 0]
                 : values;
-            return { domain: niceExtent(Math.min(...numbers), Math.max(...numbers), 10), nice: false };
+            const lo = Math.min(...numbers);
+            const hi = Math.max(...numbers);
+            return { domain: NiceTicks.domain(lo, hi, 10, niceTolerance), nice: false };
         }
         if (values.every((v) => v instanceof Date)) {
             const times = values.map((d) => +d);
@@ -139,7 +145,7 @@ export class SharedScalesPhase {
         };
         const markers = (state.markers ?? []).filter((marker) => inPanel(marker[PANEL_KEY]));
         const values = (axis) => [
-            ...ScalesPhase.processedValues(processed, axis),
+            ...ProcessedPositions.values(processed, axis),
             ...MarkerAxisValues.of(markers, axis)
         ];
         return {

package/dist/phases/statistics/Statistics.d.ts

@@ -1,4 +1,5 @@
 import type { StatisticSource } from '../../types/phases/statistics/source';
+import type { AxisChannelName } from '../../types/layout/mapping';
 import type { Series } from '../../types/plots/data/common';
 import type { StatisticConfig } from '../../types/layout/statistics';
 import type { AxisBasedMarkersConfig } from '../../types/markers/common';
@@ -10,12 +11,13 @@ import type { AxisBasedMarkersConfig } from '../../types/markers/common';
 export declare class Statistics {
     #private;
     /**
-     * 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<T extends Record<string, unknown>>(source: StatisticSource<T>, config: StatisticConfig): AxisBasedMarkersConfig;
+    static buildMarker<T extends Record<string, unknown>>(source: StatisticSource<T>, config: StatisticConfig): AxisBasedMarkersConfig[];
     /**
      * Resolves a plot's own top-level `statistics` prop against its already-built
      * `Series<T>[]` (every kind has this before `mapping` runs - see
@@ -30,6 +32,8 @@ export declare class Statistics {
     static buildForPlot<T extends Record<string, unknown>>(args: {
         series: Series<T>[];
         statistics: StatisticConfig[] | undefined;
+        /** The axis the plot measures along, from its `PlotAxes`. */
+        valueAxis?: AxisChannelName;
         colorFor?: (seriesName: string) => string;
     }): AxisBasedMarkersConfig[];
     /**
@@ -49,5 +53,5 @@ export declare class Statistics {
      */
     static expandMarkers<TMarker extends {
         type: string;
-    }, T extends Record<string, unknown>>(markers: TMarker[], fallbackData: T[]): (TMarker | AxisBasedMarkersConfig)[];
+    }, T extends Record<string, unknown>>(markers: TMarker[], fallbackData: T[], valueAxis?: AxisChannelName): (TMarker | AxisBasedMarkersConfig)[];
 }

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

@@ -1,7 +1,6 @@
 import { AuthorMarkers } from './AuthorMarkers';
 import { Statistics } from './Statistics';
-import { PANEL_KEY, FacetPhase } from '../facet/FacetPhase';
-import { TransformsPhase } from '../transforms/TransformsPhase';
+import { PANEL_KEY, FacetPanels } from '../facet/FacetPanels';
 import { PlotAxes } from '../data/PlotAxes';
 /** Marker kinds that draw from a channel pair, so they take the plot's `x`/`y` when the author leaves one out. */
 const POSITIONED_KINDS = new Set(['line', 'area', 'dot']);
@@ -25,7 +24,7 @@ export class StatisticsPhase {
     run = (state) => {
         if (!state.panels)
             return { ...state, markers: this.#resolve(state) };
-        const markers = state.panels.flatMap((panel) => this.#resolve(FacetPhase.narrowToPanel(state, panel.key)).map((marker) => ({ ...marker, [PANEL_KEY]: panel.key })));
+        const markers = state.panels.flatMap((panel) => this.#resolve(FacetPanels.narrowToPanel(state, panel.key)).map((marker) => ({ ...marker, [PANEL_KEY]: panel.key })));
         return { ...state, markers };
     };
     #resolve(state) {
@@ -51,10 +50,15 @@ export class StatisticsPhase {
         // A series setting no value of its own (a histogram's) measures its processed rows: its bins.
         const valueAxis = PlotAxes.valueOf(state);
         const measured = state.processedData && resolvedSeries.some((s) => s[valueAxis] === undefined)
-            ? TransformsPhase.buildProcessedGroups(state).map((group) => group.series)
+            ? (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,
@@ -62,7 +66,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[];
 }