@fundar/data-chart-telling 1.0.0 → 1.1.0

package/dist/phases/scales/ScalesPhase.js

@@ -1,7 +1,8 @@
-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 { NiceTicks } from '../../layout/scales/NiceTicks';
 import { DISCRETE_SCALE_TYPES } from '../../types/layout/scales';
 const AXES = ['x', 'y'];
 const POSITION_CHANNELS = {
@@ -86,15 +87,22 @@ 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, author?.niceTolerance),
+                    nice: false
+                }
+                : { ...author, domain: [lo, hi], nice: author?.nice ?? true };
         }
         const next = { ...state, scales };
         return options.extend ? options.extend(next, ctx) : next;
@@ -116,22 +124,10 @@ export class ScalesPhase {
             }
         }
         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 +143,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

@@ -13,6 +13,9 @@ type SharedScalesState = FacetStageState & {
     axes?: PlotAxes;
     processedData?: ProcessedData;
     markers?: object[];
+    scales?: Partial<Record<AxisChannelName, {
+        niceTolerance?: number;
+    }>>;
     sharedScales?: Record<string, AxisBasedScalesConfig<never>>;
 };
 /**
@@ -38,7 +41,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,8 @@
-import { nice as niceExtent } from 'd3-array';
+import { ProcessedPositions } from '../transforms/ProcessedPositions';
+import { NiceTicks } from '../../layout/scales/NiceTicks';
 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. */
@@ -49,7 +50,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 +60,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, state.scales?.[channel]?.niceTolerance);
         };
         const cache = new Map();
         const scalesOf = (place) => {
@@ -103,7 +104,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 +120,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 +142,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/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,7 +50,7 @@ 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 }),

package/dist/phases/tooltip/TooltipPhase.d.ts

@@ -2,8 +2,10 @@ import type { AxisPlotState, PhaseStage } from '../../types/phases';
 type AnyAxisState = AxisPlotState<any, any, any, any>;
 /**
  * The "tooltip" phase every axis-based plot shares: how a hovered row reads,
- * as `tooltipFormat` - the same default on every plot, {@link TooltipState.default}.
- * It runs after the scales, which say which axis holds categories.
+ * as `tooltipFormat` - the same default on every plot, {@link TooltipState.default} -
+ * and the order its rows read in, as `tooltipSort`: highest value first, by
+ * each row's own value (a stacked row's share, not its running total). It
+ * runs after the scales, which say which axis holds categories.
  */
 export declare class TooltipPhase<TState extends AnyAxisState> implements PhaseStage<TState> {
     readonly phase: "tooltip";

package/dist/phases/tooltip/TooltipPhase.js

@@ -1,10 +1,17 @@
 import { TooltipState } from '../../layout/tooltip/TooltipState.svelte';
+import { ValueLabels } from '../../layout/styles/ValueLabels';
 /**
  * The "tooltip" phase every axis-based plot shares: how a hovered row reads,
- * as `tooltipFormat` - the same default on every plot, {@link TooltipState.default}.
- * It runs after the scales, which say which axis holds categories.
+ * as `tooltipFormat` - the same default on every plot, {@link TooltipState.default} -
+ * and the order its rows read in, as `tooltipSort`: highest value first, by
+ * each row's own value (a stacked row's share, not its running total). It
+ * runs after the scales, which say which axis holds categories.
  */
 export class TooltipPhase {
     phase = 'tooltip';
-    run = (state) => ({ ...state, tooltipFormat: TooltipState.default(state) });
+    run = (state) => ({
+        ...state,
+        tooltipFormat: TooltipState.default(state),
+        tooltipSort: TooltipState.descending(ValueLabels.valueOf(state))
+    });
 }

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

@@ -0,0 +1,30 @@
+import type { AxisChannelName } from '../../types/layout/mapping';
+import type { ProcessedData, ProcessedRow } from '../../types/phases';
+/**
+ * Where the "transforms" phase's processed rows sit, read off its output
+ * (`state.processedData`) - by whichever channels the transforms left: a
+ * row's own value, a stack's `1`-`2` span, a bin's edges. Every later phase
+ * reads positions through it instead of telling those channels apart itself.
+ */
+export declare class ProcessedPositions {
+    /**
+     * Where a processed row sits: the top of its value (`y2`, or `y` - `x2`/`x`
+     * when `valueAxis` is `x`) and, on the other axis, its own position (or the
+     * middle of its `1`-`2` span, a bin's centre).
+     */
+    static of(processed: ProcessedData, valueAxis?: 'x' | 'y'): {
+        x: (row: ProcessedRow) => unknown;
+        y: (row: ProcessedRow) => unknown;
+    };
+    /**
+     * A processed row's span along `valueAxis`: from its `1` channel (a stack's
+     * bottom) or, with none, from `baseline`, to its top. `undefined` when the
+     * row has no value there. `stacked` tells a stack from plain values.
+     */
+    static span(processed: ProcessedData, valueAxis: 'x' | 'y', baseline?: number): {
+        stacked: boolean;
+        of: (row: ProcessedRow) => [number, number] | undefined;
+    };
+    /** Every value the processed rows sit at on one axis, through each of its channels. */
+    static values(processed: ProcessedData | undefined, axis: AxisChannelName): unknown[];
+}

package/dist/phases/transforms/ProcessedPositions.js

@@ -0,0 +1,74 @@
+import { resolveAccessor } from '../../plots/utils/accessors';
+import { isGapValue } from '../../plots/utils/gaps';
+const POSITION_CHANNELS = {
+    x: ['x', 'x1', 'x2'],
+    y: ['y', 'y1', 'y2']
+};
+/**
+ * Where the "transforms" phase's processed rows sit, read off its output
+ * (`state.processedData`) - by whichever channels the transforms left: a
+ * row's own value, a stack's `1`-`2` span, a bin's edges. Every later phase
+ * reads positions through it instead of telling those channels apart itself.
+ */
+export class ProcessedPositions {
+    /**
+     * Where a processed row sits: the top of its value (`y2`, or `y` - `x2`/`x`
+     * when `valueAxis` is `x`) and, on the other axis, its own position (or the
+     * middle of its `1`-`2` span, a bin's centre).
+     */
+    static of(processed, valueAxis = 'y') {
+        const { channels } = processed;
+        const read = (channel) => resolveAccessor(channel);
+        const along = (axis) => {
+            const own = channels[axis];
+            const from = channels[`${axis}1`];
+            const to = channels[`${axis}2`];
+            if (axis === valueAxis) {
+                const top = to ?? own;
+                return top !== undefined ? read(top) : () => undefined;
+            }
+            if (own !== undefined)
+                return read(own);
+            if (from === undefined || to === undefined)
+                return () => undefined;
+            return (row) => (Number(read(from)(row)) + Number(read(to)(row))) / 2;
+        };
+        return { x: along('x'), y: along('y') };
+    }
+    /**
+     * A processed row's span along `valueAxis`: from its `1` channel (a stack's
+     * bottom) or, with none, from `baseline`, to its top. `undefined` when the
+     * row has no value there. `stacked` tells a stack from plain values.
+     */
+    static span(processed, valueAxis, baseline = 0) {
+        const from = processed.channels[`${valueAxis}1`];
+        const stacked = from !== undefined && processed.channels[`${valueAxis}2`] !== undefined;
+        const top = ProcessedPositions.of(processed, valueAxis)[valueAxis];
+        const bottom = stacked
+            ? resolveAccessor(from)
+            : () => baseline;
+        return {
+            stacked,
+            of: (row) => {
+                const end = top(row);
+                const start = bottom(row);
+                if (isGapValue(end) || isGapValue(start))
+                    return undefined;
+                const span = [Number(start), Number(end)];
+                return Number.isFinite(span[0]) && Number.isFinite(span[1]) ? span : undefined;
+            }
+        };
+    }
+    /** Every value the processed rows sit at on one axis, through each of its channels. */
+    static values(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));
+        });
+    }
+}

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

@@ -1,7 +1,4 @@
-import type { Series } from '../../types/plots/data/common';
-import type { SegmentsConfig } from '../../types/plots/props';
-import type { VisualGroup } from '../../types/plots/segments/config';
-import type { PhaseStage, ProcessedData, ProcessedRow, TransformsStageOptions, TransformsStageState } from '../../types/phases';
+import type { PhaseStage, TransformsStageOptions, TransformsStageState } from '../../types/phases';
 /** The field each processed row carries its series name under, for its color, legend and labels. */
 export declare const SERIES_KEY = "__series";
 /** The field each processed row carries its series id under - the transforms' `z`, so a stack or bin keeps series apart. */
@@ -14,7 +11,8 @@ export declare const GAP_KIND = "__gapKind";
  * The "transforms" phase every axis-based plot shares: runs the plot-level
  * transforms once over every visible series' rows together, so a stack sees
  * every series and a bin keeps each series apart (both group by series), and
- * leaves the result in `state.processedData` for the plot's own marks. With
+ * leaves the result in `state.processedData` for the plot's own marks - and
+ * in `state.processedGroups`, split back into the visual groups they draw. With
  * facet panels, the transforms run once per panel's rows, so a stack never
  * combines two panels, and every row they return keeps its panel. A gap that
  * `styles.gaps` fills is read at its interpolated value, so it takes its place
@@ -23,42 +21,7 @@ export declare const GAP_KIND = "__gapKind";
 export declare class TransformsPhase<TState extends TransformsStageState, TCtx = unknown> implements PhaseStage<TState, TCtx> {
     #private;
     readonly phase: "transforms";
-    constructor(options?: TransformsStageOptions<TState, TCtx>);
+    /** `connect`: whether a series' visual segments bridge into each other, as the kind's "data" phase splits them. */
+    constructor(options?: TransformsStageOptions<TState, TCtx>, connect?: boolean);
     run: (state: TState, ctx: TCtx) => TState;
-    /**
-     * The processed rows split back into one group per visible series, each cut
-     * into its styled visual segments by `segments`, matched on the processed `x`.
-     * Each series reads its rows through its value axis: a stack's top, a bin's start.
-     */
-    static buildProcessedGroups<TStyle>(state: TransformsStageState & {
-        segments?: SegmentsConfig<TStyle>;
-    }, connect?: boolean): VisualGroup<Series<ProcessedRow>, TStyle>[];
-    /**
-     * The processed rows in their own order, split into runs of consecutive rows
-     * from the same visible series, each cut into its styled visual segments like
-     * {@link TransformsPhase.buildProcessedGroups}. Drawn in turn, the runs keep the rows' order
-     * across series, so a transform that reorders rows (`sort`, `reverse`,
-     * `shuffle`) decides which rows paint on top. Unreordered, each series is one run.
-     */
-    static buildProcessedRuns<TStyle>(state: TransformsStageState & {
-        segments?: SegmentsConfig<TStyle>;
-    }): VisualGroup<Series<ProcessedRow>, TStyle>[];
-    /**
-     * Where a processed row sits: the top of its value (`y2`, or `y` - `x2`/`x`
-     * when `valueAxis` is `x`) and, on the other axis, its own position (or the
-     * middle of its `1`-`2` span, a bin's centre).
-     */
-    static processedPosition(processed: ProcessedData, valueAxis?: 'x' | 'y'): {
-        x: (row: ProcessedRow) => unknown;
-        y: (row: ProcessedRow) => unknown;
-    };
-    /**
-     * A processed row's span along `valueAxis`: from its `1` channel (a stack's
-     * bottom) or, with none, from `baseline`, to its top. `undefined` when the
-     * row has no value there. `stacked` tells a stack from plain values.
-     */
-    static processedSpan(processed: ProcessedData, valueAxis: 'x' | 'y', baseline?: number): {
-        stacked: boolean;
-        of: (row: ProcessedRow) => [number, number] | undefined;
-    };
 }

package/dist/phases/transforms/TransformsPhase.js

@@ -1,8 +1,7 @@
 import { Transforms } from './Transforms';
 import { seriesIdOf } from '../../utils/grouping';
-import { PANEL_KEY } from '../facet/FacetPhase';
+import { PANEL_KEY } from '../facet/FacetPanels';
 import { resolveAccessor } from '../../plots/utils/accessors';
-import { isGapValue } from '../../plots/utils/gaps';
 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. */
@@ -20,7 +19,8 @@ const NOT_OPTIONS = new Set(['data', 'z', 'grouping', 'transforms', 'sort', 'fil
  * The "transforms" phase every axis-based plot shares: runs the plot-level
  * transforms once over every visible series' rows together, so a stack sees
  * every series and a bin keeps each series apart (both group by series), and
- * leaves the result in `state.processedData` for the plot's own marks. With
+ * leaves the result in `state.processedData` for the plot's own marks - and
+ * in `state.processedGroups`, split back into the visual groups they draw. With
  * facet panels, the transforms run once per panel's rows, so a stack never
  * combines two panels, and every row they return keeps its panel. A gap that
  * `styles.gaps` fills is read at its interpolated value, so it takes its place
@@ -29,8 +29,11 @@ const NOT_OPTIONS = new Set(['data', 'z', 'grouping', 'transforms', 'sort', 'fil
 export class TransformsPhase {
     phase = 'transforms';
     #options;
-    constructor(options = {}) {
+    #connect;
+    /** `connect`: whether a series' visual segments bridge into each other, as the kind's "data" phase splits them. */
+    constructor(options = {}, connect = true) {
         this.#options = options;
+        this.#connect = connect;
     }
     run = (state, ctx) => {
         const options = this.#options;
@@ -62,7 +65,7 @@ export class TransformsPhase {
         if (!transforms.length) {
             const channels = Object.fromEntries(Object.entries({ x, y }).filter(([, channel]) => channel !== undefined));
             const processedData = { data, channels, options: {}, transforms };
-            return { ...state, processedData };
+            return this.#withGroups({ ...state, processedData });
         }
         const out = TransformsPhase.#runByPanel(data, (rows) => Transforms.resolve({ data: rows, x, y, grouping: SERIES_ID_KEY, transforms }, rows));
         const channels = {};
@@ -89,8 +92,15 @@ export class TransformsPhase {
             options: markOptions,
             transforms
         };
-        return { ...state, processedData };
+        return this.#withGroups({ ...state, processedData });
     };
+    /** `state` with its processed rows split into the visual groups the kind's marks draw (`processedGroups`). */
+    #withGroups(state) {
+        const processedGroups = this.#options.groups === 'runs'
+            ? TransformsPhase.#buildRuns(state)
+            : TransformsPhase.#buildGroups(state, this.#connect);
+        return { ...state, processedGroups };
+    }
     /** What a gap-filled row carries: its interpolated value and the kind of zone that filled it. */
     static #fillTags(fill) {
         return fill ? { [GAP_VALUE]: fill.value, [GAP_KIND]: fill.kind } : {};
@@ -100,7 +110,7 @@ export class TransformsPhase {
      * into its styled visual segments by `segments`, matched on the processed `x`.
      * Each series reads its rows through its value axis: a stack's top, a bin's start.
      */
-    static buildProcessedGroups(state, connect = true) {
+    static #buildGroups(state, connect) {
         const { data } = state.processedData;
         const series = (state.resolvedSeries ?? []).map((s) => TransformsPhase.#processedSeries(state, s, data.filter((row) => row[SERIES_ID_KEY] === seriesIdOf(s))));
         return buildGroupedSeries(series, state.segments, connect);
@@ -108,11 +118,11 @@ export class TransformsPhase {
     /**
      * The processed rows in their own order, split into runs of consecutive rows
      * from the same visible series, each cut into its styled visual segments like
-     * {@link TransformsPhase.buildProcessedGroups}. Drawn in turn, the runs keep the rows' order
+     * {@link TransformsPhase.#buildGroups}. Drawn in turn, the runs keep the rows' order
      * across series, so a transform that reorders rows (`sort`, `reverse`,
      * `shuffle`) decides which rows paint on top. Unreordered, each series is one run.
      */
-    static buildProcessedRuns(state) {
+    static #buildRuns(state) {
         const byId = new Map((state.resolvedSeries ?? []).map((s) => [seriesIdOf(s), s]));
         const runs = [];
         for (const row of state.processedData.data) {
@@ -127,54 +137,6 @@ export class TransformsPhase {
         }
         return buildGroupedSeries(runs, state.segments, false);
     }
-    /**
-     * Where a processed row sits: the top of its value (`y2`, or `y` - `x2`/`x`
-     * when `valueAxis` is `x`) and, on the other axis, its own position (or the
-     * middle of its `1`-`2` span, a bin's centre).
-     */
-    static processedPosition(processed, valueAxis = 'y') {
-        const { channels } = processed;
-        const read = (channel) => resolveAccessor(channel);
-        const along = (axis) => {
-            const own = channels[axis];
-            const from = channels[`${axis}1`];
-            const to = channels[`${axis}2`];
-            if (axis === valueAxis) {
-                const top = to ?? own;
-                return top !== undefined ? read(top) : () => undefined;
-            }
-            if (own !== undefined)
-                return read(own);
-            if (from === undefined || to === undefined)
-                return () => undefined;
-            return (row) => (Number(read(from)(row)) + Number(read(to)(row))) / 2;
-        };
-        return { x: along('x'), y: along('y') };
-    }
-    /**
-     * A processed row's span along `valueAxis`: from its `1` channel (a stack's
-     * bottom) or, with none, from `baseline`, to its top. `undefined` when the
-     * row has no value there. `stacked` tells a stack from plain values.
-     */
-    static processedSpan(processed, valueAxis, baseline = 0) {
-        const from = processed.channels[`${valueAxis}1`];
-        const stacked = from !== undefined && processed.channels[`${valueAxis}2`] !== undefined;
-        const top = TransformsPhase.processedPosition(processed, valueAxis)[valueAxis];
-        const bottom = stacked
-            ? resolveAccessor(from)
-            : () => baseline;
-        return {
-            stacked,
-            of: (row) => {
-                const end = top(row);
-                const start = bottom(row);
-                if (isGapValue(end) || isGapValue(start))
-                    return undefined;
-                const span = [Number(start), Number(end)];
-                return Number.isFinite(span[0]) && Number.isFinite(span[1]) ? span : undefined;
-            }
-        };
-    }
     /**
      * One series accessor shared by every series as-is, so a field key keeps
      * feeding svelteplot's axis-title inference; a per-series function otherwise.
@@ -234,6 +196,7 @@ export class TransformsPhase {
         return {
             name: source.name,
             ...(source.id !== undefined ? { id: source.id } : {}),
+            ...(source.panel !== undefined ? { panel: source.panel } : {}),
             x: read('x'),
             y: read('y'),
             data

package/dist/plots/area/markers.js

@@ -1,4 +1,3 @@
-import { TransformsPhase } from '../../phases/transforms/TransformsPhase';
 import { Transforms } from '../../phases/transforms/Transforms';
 /**
  * AreaPlot's "markers" phase: one `area` per visual segment of each series,
@@ -27,7 +26,7 @@ export function buildMarks(state, ctx) {
     };
     // The dim channel: each area reads its own series name, looked up in `opacityScale`.
     const dimByName = (name) => dimmed ? { opacity: () => name, scales: { opacity: opacityScale } } : {};
-    const areas = TransformsPhase.buildProcessedGroups(state).flatMap((group) => group.visualSegments.map((seg) => Transforms.finish({
+    const areas = (state.processedGroups ?? []).flatMap((group) => group.visualSegments.map((seg) => Transforms.finish({
         type: 'area',
         series: group.series.name,
         data: seg.data,

package/dist/plots/bar/defaults.js

@@ -1,7 +1,7 @@
+import { ProcessedPositions } from '../../phases/transforms/ProcessedPositions';
 import { buildMarks, buildValueLabels, buildHitAreas, buildBarGeometry } from './markers';
-import { niceDomain, naturalTickCount } from '../../layout/scales/niceDomain';
-import { Margins } from '../../layout/margins/Margins';
-import { SERIES_KEY, TransformsPhase } from '../../phases/transforms/TransformsPhase';
+import { NiceTicks } from '../../layout/scales/NiceTicks';
+import { SERIES_KEY } from '../../phases/transforms/TransformsPhase';
 import { PlotAxes } from '../../phases/data/PlotAxes';
 /**
  * The domain a bar plot fits to its own bars on its value axis: from zero to
@@ -9,14 +9,13 @@ import { PlotAxes } from '../../phases/data/PlotAxes';
  * author pins the axis, and when there is no span to fit.
  */
 function fitValueDomain(state) {
-    const isHorizontal = state.axes?.isHorizontal ?? false;
     const axis = PlotAxes.valueOf(state);
     const scale = state.scales[axis];
     if (scale?.domain != null || scale?.ticks != null || scale?.nice != null)
         return {};
     // Every bar's span, as the "transforms" phase left it - its baseline is
     // unknown until the domain is, so a plain bar reads as reaching from zero.
-    const { of: spanOf } = TransformsPhase.processedSpan(state.processedData, axis);
+    const { of: spanOf } = ProcessedPositions.span(state.processedData, axis);
     let lo = 0;
     let hi = 0;
     for (const row of state.processedData?.data ?? []) {
@@ -28,10 +27,7 @@ function fitValueDomain(state) {
     }
     if (hi <= lo)
         return {};
-    const spacing = isHorizontal ? 80 : 50;
-    const box = Margins.AXIS_ESTIMATE.contentBox(state.width, state.height);
-    const count = naturalTickCount(isHorizontal ? box.width : box.height, spacing, 2);
-    return { [axis]: { domain: niceDomain(lo, hi, count) } };
+    return { [axis]: { domain: NiceTicks.fit(state, axis, lo, hi, scale?.niceTolerance) } };
 }
 /**
  * BarPlot on the shared pipeline: discrete bars with gap fills along one
@@ -59,7 +55,7 @@ export function buildBarDefaults() {
                     if (labels.anchor !== 'outside')
                         return [];
                     const axis = PlotAxes.valueOf(state);
-                    if (TransformsPhase.processedSpan(state.processedData, axis).stacked)
+                    if (ProcessedPositions.span(state.processedData, axis).stacked)
                         return [];
                     if (!state.axes?.isHorizontal) {
                         const at = { y: -labels.offset('y') };

package/dist/plots/bar/markers.js

@@ -1,5 +1,6 @@
+import { ProcessedPositions } from '../../phases/transforms/ProcessedPositions';
 import { getConfiguration } from '../../configuration/config.svelte';
-import { GAP_KIND, GAP_VALUE, SERIES_ID_KEY, TransformsPhase } from '../../phases/transforms/TransformsPhase';
+import { GAP_KIND, GAP_VALUE, SERIES_ID_KEY } from '../../phases/transforms/TransformsPhase';
 import { seriesIdOf } from '../../utils/grouping';
 import { resolveGapAreaStyle } from '../utils/gaps';
 import { PlotAxes } from '../../phases/data/PlotAxes';
@@ -24,8 +25,8 @@ export function buildBarGeometry(state, seriesPadding) {
         const [min, max] = [Math.min(lo, hi), Math.max(lo, hi)];
         return min > 0 ? min : max < 0 ? max : 0;
     })();
-    const { stacked, of: spanOf } = TransformsPhase.processedSpan(state.processedData, valueAxis, baseline);
-    const position = TransformsPhase.processedPosition(state.processedData, valueAxis);
+    const { stacked, of: spanOf } = ProcessedPositions.span(state.processedData, valueAxis, baseline);
+    const position = ProcessedPositions.of(state.processedData, valueAxis);
     const categoryOf = (row) => position[categoryAxis](row);
     const names = [...new Set((state.groupedSeries ?? []).map((g) => g.series.name))];
     // A lone series, or a stack, fills its whole band: there's nothing to set side by side.
@@ -197,7 +198,7 @@ export function buildMarks(state, ctx) {
     }
     const isReal = (row) => row[GAP_VALUE] === undefined && geometry.spanOf(row) !== undefined;
     const segmentMarkers = [];
-    TransformsPhase.buildProcessedGroups(state, false).forEach((group) => {
+    (state.processedGroups ?? []).forEach((group) => {
         const name = group.series.name;
         const slice = geometry.sliceOf(name);
         const defaultColor = colorForSeries(name);

package/dist/plots/box/BoxSummaries.d.ts

@@ -0,0 +1,19 @@
+import type { HoverPosition } from '../../types/phases';
+import type { BoxPlotState, BoxSummaryRow } from '../../types/plots/box/state';
+/**
+ * The boxes a box plot draws, one summary row per series, category and facet
+ * panel - the same quartiles and whiskers svelteplot's `BoxX`/`BoxY` compute,
+ * so its hover and tooltip read a box rather than every value inside it.
+ */
+export declare class BoxSummaries {
+    /** One summary per box, in the order the processed rows first reach it. */
+    static of<TData extends Record<string, unknown>>(state: BoxPlotState<TData>): BoxSummaryRow[];
+    /** Where a box's summary sits for hover: at its category, level with its median. */
+    static position<TData extends Record<string, unknown>>(state: BoxPlotState<TData>): HoverPosition;
+    /**
+     * How a hovered box reads by default: its series, when the plot groups its
+     * rows; its category; then its five numbers, highest first, and how many
+     * values fall past the whiskers.
+     */
+    static format<TData extends Record<string, unknown>>(state: BoxPlotState<TData>): (row: BoxSummaryRow) => string;
+}