@fundar/data-chart-telling 1.0.0 → 1.2.0

package/dist/phases/data/DataPhase.d.ts

@@ -1,12 +1,12 @@
-import type { Accessor } from '../../types/plots/data/common';
 import type { AxisPlotState, AxisPlotCtx, DataStageOptions, PhaseStage } from '../../types/phases';
 type AnyAxisState = AxisPlotState<any, any, any, any>;
 /**
  * The "data" phase every axis-based plot shares: its series (from `series`,
- * or flat rows split by {@link DataPhase.buildGrouping}), what each position
- * channel is and which way the plot runs ({@link PlotAxes}), each series'
- * color, the series a legend omits dropped, each series cut into its styled
- * visual segments, and - for a discrete mark - the values its gaps fill in.
+ * or flat rows split by `seriesGrouping`: its `grouping`, or a categorical
+ * `color`), what each position channel is and which way the plot runs
+ * ({@link PlotAxes}), each series' color, the series a legend omits dropped,
+ * each series cut into its styled visual segments, and - for a discrete
+ * mark - the values its gaps fill in.
  * Colors and axes come from every series, before any is omitted or split by
  * facet panel, so they stay put and every panel agrees.
  */
@@ -15,11 +15,5 @@ export declare class DataPhase<TState extends AnyAxisState, TCtx extends AxisPlo
     readonly phase: "data";
     constructor(options?: DataStageOptions<TState, TCtx>);
     run: (state: TState, ctx: TCtx) => TState;
-    /**
-     * The key a plot's rows split into series by: its `grouping`, or its `color`
-     * when that names categories. A numeric `color` is a continuous value (a
-     * heatmap's cells), so it colors rows without grouping them.
-     */
-    static buildGrouping(state: Pick<AnyAxisState, 'grouping' | 'color' | 'data'>): Accessor<any, unknown> | undefined;
 }
 export {};

package/dist/phases/data/DataPhase.js

@@ -1,16 +1,17 @@
 import { buildSeries } from '../../utils/grouping';
-import { resolveColorScale } from '../../utils/color';
-import { resolveAccessor } from '../../plots/utils/accessors';
+import { ColorRamp } from '../../utils/color';
+import { resolveAccessor } from '../../utils/accessors';
 import { buildGroupedSeries, buildScopedMarkerGroups } from '../../plots/utils/segments';
 import { buildGapFillMaps, isGapValue } from '../../plots/utils/gaps';
-import { FacetPhase } from '../facet/FacetPhase';
+import { FacetPanels } from '../facet/FacetPanels';
 import { PlotAxes } from './PlotAxes';
 /**
  * The "data" phase every axis-based plot shares: its series (from `series`,
- * or flat rows split by {@link DataPhase.buildGrouping}), what each position
- * channel is and which way the plot runs ({@link PlotAxes}), each series'
- * color, the series a legend omits dropped, each series cut into its styled
- * visual segments, and - for a discrete mark - the values its gaps fill in.
+ * or flat rows split by `seriesGrouping`: its `grouping`, or a categorical
+ * `color`), what each position channel is and which way the plot runs
+ * ({@link PlotAxes}), each series' color, the series a legend omits dropped,
+ * each series cut into its styled visual segments, and - for a discrete
+ * mark - the values its gaps fill in.
  * Colors and axes come from every series, before any is omitted or split by
  * facet panel, so they stay put and every panel agrees.
  */
@@ -24,7 +25,8 @@ export class DataPhase {
         const options = this.#options;
         const { series, data, segments, scales } = state;
         const { connect = true, color: segmentColor } = options.segments ?? {};
-        const built = series ?? buildSeries(data ?? [], state.x, state.y, DataPhase.buildGrouping(state));
+        const seriesGrouping = DataPhase.#buildGrouping(state);
+        const built = series ?? buildSeries(data ?? [], state.x, state.y, seriesGrouping);
         const fullSeries = options.orderSeries ? options.orderSeries(built, state) : built;
         const axes = PlotAxes.build({
             series: fullSeries,
@@ -32,9 +34,9 @@ export class DataPhase {
             given: { x: state.x !== undefined, y: state.y !== undefined },
             discrete: options.discreteAxes
         });
-        const colorForSeries = resolveColorScale(scales.color, (options.colorOrder ? options.colorOrder(fullSeries) : fullSeries).map((s) => s.name), ctx.cfg.palette);
+        const colorForSeries = ColorRamp.resolve(scales.color, (options.colorOrder ? options.colorOrder(fullSeries) : fullSeries).map((s) => s.name), ctx.cfg.palette);
         const panelSeries = state.panels && state.panelOf && !series
-            ? FacetPhase.splitSeriesByPanel(fullSeries, state.panels, state.panelOf)
+            ? FacetPanels.splitSeries(fullSeries, state.panels, state.panelOf)
             : fullSeries;
         const resolvedSeries = ctx.interaction?.legend?.withoutOmitted(panelSeries) ?? panelSeries;
         const groupedSeries = buildGroupedSeries(resolvedSeries, segments, connect);
@@ -52,6 +54,7 @@ export class DataPhase {
             ...state,
             axes,
             resolvedSeries,
+            seriesGrouping,
             allSeriesNames: fullSeries.map((s) => s.name),
             groupedSeries,
             flat: resolvedSeries.flatMap((s) => s.data),
@@ -66,7 +69,7 @@ export class DataPhase {
      * when that names categories. A numeric `color` is a continuous value (a
      * heatmap's cells), so it colors rows without grouping them.
      */
-    static buildGrouping(state
+    static #buildGrouping(state
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) {
         if (state.grouping !== undefined)

package/dist/phases/data/PlotAxes.d.ts

@@ -58,6 +58,16 @@ export declare class PlotAxes {
     static categoryOf(state: {
         axes?: PlotAxes;
     }): AxisChannelName;
+    /**
+     * Where marks that rise from a baseline start along the value axis: zero,
+     * or the nearest end of a pinned domain that leaves zero out.
+     */
+    static baselineOf(state: {
+        axes?: PlotAxes;
+        scales: Partial<Record<AxisChannelName, {
+            domain?: readonly unknown[];
+        }>>;
+    }): number;
     /** The other position axis. */
     static other(axis: AxisChannelName): AxisChannelName;
     /**

package/dist/phases/data/PlotAxes.js

@@ -1,4 +1,4 @@
-import { resolveAccessor } from '../../plots/utils/accessors';
+import { resolveAccessor } from '../../utils/accessors';
 import { isGapValue } from '../../plots/utils/gaps';
 import { DISCRETE_SCALE_TYPES, TEMPORAL_SCALE_TYPES } from '../../types/layout/scales';
 const AXES = ['x', 'y'];
@@ -47,6 +47,19 @@ export class PlotAxes {
     static categoryOf(state) {
         return state.axes?.category ?? 'x';
     }
+    /**
+     * Where marks that rise from a baseline start along the value axis: zero,
+     * or the nearest end of a pinned domain that leaves zero out.
+     */
+    static baselineOf(state) {
+        const domain = state.scales[PlotAxes.valueOf(state)]?.domain;
+        const lo = Number(domain?.[0]);
+        const hi = Number(domain?.[(domain?.length ?? 1) - 1]);
+        if (!domain || domain.length < 2 || Number.isNaN(lo) || Number.isNaN(hi))
+            return 0;
+        const [min, max] = [Math.min(lo, hi), Math.max(lo, hi)];
+        return min > 0 ? min : max < 0 ? max : 0;
+    }
     /** The other position axis. */
     static other(axis) {
         return axis === 'x' ? 'y' : 'x';

package/dist/phases/facet/FacetPanels.d.ts

@@ -0,0 +1,55 @@
+import type { Series } from '../../types/plots/data/common';
+import type { FacetPanel, FacetStageState } from '../../types/phases';
+/** The state fields narrowing to some panels filters. */
+type NarrowableState = FacetStageState & {
+    resolvedSeries?: Series<Record<string, unknown>>[];
+    flat?: unknown[];
+    scopedGroups?: {
+        panel?: string;
+    }[];
+    groupedSeries?: {
+        series: {
+            panel?: string;
+        };
+    }[];
+    processedData?: {
+        data: Record<string | symbol, unknown>[];
+    };
+    processedGroups?: {
+        series: {
+            panel?: string;
+        };
+    }[];
+    labelled?: Record<string | symbol, unknown>[];
+};
+/** The field a processed row carries its facet panel under. */
+export declare const PANEL_KEY = "__panel";
+/**
+ * What the "facet" phase's panels do to the rest of a plot's state: each
+ * series split into one per panel, a state narrowed to some panels, and one
+ * panel's part of a run over every panel.
+ */
+export declare class FacetPanels {
+    /** The id of a series' part in one facet panel. */
+    static buildSeriesId(panel: string, name: string): string;
+    /**
+     * Each series split into one per facet panel, panel by panel: the same
+     * `name` (and so the same color and legend entry), its own `id` and `panel`,
+     * and only that panel's rows. A series with no rows in a panel has no part there.
+     */
+    static splitSeries<S extends Series<Record<string, unknown>>>(series: S[], panels: FacetPanel[], panelOf: NonNullable<FacetStageState['panelOf']>): S[];
+    /** A state narrowed to one panel's series, rows and processed rows. */
+    static narrowToPanel<TState extends NarrowableState>(state: TState, panel: string): TState;
+    /** A state narrowed to some panels' series, rows and processed rows. */
+    static narrowToPanels<TState extends NarrowableState>(state: TState, panels: readonly string[]): TState;
+    /**
+     * One facet panel's part of a run of the data phases over every panel: its
+     * series, rows, processed rows and markers, without the facet itself, ready
+     * for the phases each panel runs on its own.
+     */
+    static buildPanelState<TState extends FacetStageState & {
+        resolvedSeries?: Series<Record<string, unknown>>[];
+        markers?: object[];
+    }>(state: TState, panel: string): Omit<TState, 'facet' | 'panels' | 'panelOf'>;
+}
+export {};

package/dist/phases/facet/FacetPanels.js

@@ -0,0 +1,96 @@
+/** The field a processed row carries its facet panel under. */
+export const PANEL_KEY = '__panel';
+/**
+ * What the "facet" phase's panels do to the rest of a plot's state: each
+ * series split into one per panel, a state narrowed to some panels, and one
+ * panel's part of a run over every panel.
+ */
+export class FacetPanels {
+    /** The id of a series' part in one facet panel. */
+    static buildSeriesId(panel, name) {
+        return `${panel}\u0000${name}`;
+    }
+    /**
+     * Each series split into one per facet panel, panel by panel: the same
+     * `name` (and so the same color and legend entry), its own `id` and `panel`,
+     * and only that panel's rows. A series with no rows in a panel has no part there.
+     */
+    static splitSeries(series, panels, panelOf) {
+        const rowsByPanel = series.map((s) => {
+            const groups = new Map();
+            for (const row of s.data) {
+                const key = panelOf(row);
+                if (key === undefined)
+                    continue;
+                const bucket = groups.get(key);
+                if (bucket)
+                    bucket.push(row);
+                else
+                    groups.set(key, [row]);
+            }
+            return groups;
+        });
+        return panels.flatMap((panel) => series.flatMap((s, i) => {
+            const rows = rowsByPanel[i].get(panel.key);
+            if (!rows?.length)
+                return [];
+            return [
+                {
+                    ...s,
+                    id: FacetPanels.buildSeriesId(panel.key, s.name),
+                    panel: panel.key,
+                    data: rows
+                }
+            ];
+        }));
+    }
+    /** A state narrowed to one panel's series, rows and processed rows. */
+    static narrowToPanel(state, panel) {
+        return FacetPanels.narrowToPanels(state, [panel]);
+    }
+    /** A state narrowed to some panels' series, rows and processed rows. */
+    static narrowToPanels(state, panels) {
+        const keep = new Set(panels);
+        const has = (panel) => keep.has(panel);
+        const resolvedSeries = state.resolvedSeries?.filter((s) => has(s.panel));
+        const { panelOf } = state;
+        return {
+            ...state,
+            resolvedSeries,
+            flat: panelOf
+                ? state.flat?.filter((row) => has(panelOf(row)))
+                : resolvedSeries?.flatMap((s) => s.data),
+            scopedGroups: state.scopedGroups?.filter((g) => has(g.panel)),
+            groupedSeries: state.groupedSeries?.filter((g) => has(g.series.panel)),
+            processedGroups: state.processedGroups?.filter((g) => has(g.series.panel)),
+            labelled: state.labelled?.filter((row) => has(row[PANEL_KEY])),
+            processedData: state.processedData && {
+                ...state.processedData,
+                data: state.processedData.data.filter((row) => has(row[PANEL_KEY]))
+            }
+        };
+    }
+    /**
+     * One facet panel's part of a run of the data phases over every panel: its
+     * series, rows, processed rows and markers, without the facet itself, ready
+     * for the phases each panel runs on its own.
+     */
+    static buildPanelState(state, panel) {
+        const narrowed = FacetPanels.narrowToPanel(state, panel);
+        const markers = state.markers?.flatMap((marker) => {
+            const own = marker;
+            if (own[PANEL_KEY] === undefined)
+                return [marker];
+            if (own[PANEL_KEY] !== panel)
+                return [];
+            const untagged = { ...own };
+            delete untagged[PANEL_KEY];
+            return [untagged];
+        });
+        const out = { ...narrowed, markers };
+        delete out.facet;
+        delete out.panels;
+        delete out.panelOf;
+        return out;
+    }
+}

package/dist/phases/facet/FacetPhase.d.ts

@@ -1,23 +1,4 @@
-import type { Series } from '../../types/plots/data/common';
-import type { FacetPanel, FacetStageState, PhaseStage } from '../../types/phases';
-/** The state fields narrowing to some panels filters. */
-type NarrowableState = FacetStageState & {
-    resolvedSeries?: Series<Record<string, unknown>>[];
-    flat?: unknown[];
-    scopedGroups?: {
-        panel?: string;
-    }[];
-    groupedSeries?: {
-        series: {
-            panel?: string;
-        };
-    }[];
-    processedData?: {
-        data: Record<string | symbol, unknown>[];
-    };
-};
-/** The field a processed row carries its facet panel under. */
-export declare const PANEL_KEY = "__panel";
+import type { FacetStageState, PhaseStage } from '../../types/phases';
 /**
  * The "facet" phase: the panels the plot's `facet` lays its rows out in, and
  * which panel each row belongs to. It runs first, so the "data" phase builds
@@ -27,26 +8,4 @@ export declare const PANEL_KEY = "__panel";
 export declare class FacetPhase<TState extends FacetStageState> implements PhaseStage<TState> {
     readonly phase: "facet";
     run: (state: TState) => TState;
-    /** The id of a series' part in one facet panel. */
-    static buildPanelSeriesId(panel: string, name: string): string;
-    /**
-     * Each series split into one per facet panel, panel by panel: the same
-     * `name` (and so the same color and legend entry), its own `id` and `panel`,
-     * and only that panel's rows. A series with no rows in a panel has no part there.
-     */
-    static splitSeriesByPanel<S extends Series<Record<string, unknown>>>(series: S[], panels: FacetPanel[], panelOf: NonNullable<FacetStageState['panelOf']>): S[];
-    /** A state narrowed to one panel's series, rows and processed rows. */
-    static narrowToPanel<TState extends NarrowableState>(state: TState, panel: string): TState;
-    /** A state narrowed to some panels' series, rows and processed rows. */
-    static narrowToPanels<TState extends NarrowableState>(state: TState, panels: readonly string[]): TState;
-    /**
-     * One facet panel's part of a run of the data phases over every panel: its
-     * series, rows, processed rows and markers, without the facet itself, ready
-     * for the phases each panel runs on its own.
-     */
-    static buildPanelState<TState extends FacetStageState & {
-        resolvedSeries?: Series<Record<string, unknown>>[];
-        markers?: object[];
-    }>(state: TState, panel: string): Omit<TState, 'facet' | 'panels' | 'panelOf'>;
 }
-export {};

package/dist/phases/facet/FacetPhase.js

@@ -1,6 +1,5 @@
 import { buildFacetKeyOf, buildFacetPanels } from '../../layout/facet/config';
-/** The field a processed row carries its facet panel under. */
-export const PANEL_KEY = '__panel';
+import { PANEL_KEY } from './FacetPanels';
 /**
  * The "facet" phase: the panels the plot's `facet` lays its rows out in, and
  * which panel each row belongs to. It runs first, so the "data" phase builds
@@ -26,89 +25,4 @@ export class FacetPhase {
         };
         return { ...state, panels, panelOf };
     };
-    /** The id of a series' part in one facet panel. */
-    static buildPanelSeriesId(panel, name) {
-        return `${panel}\u0000${name}`;
-    }
-    /**
-     * Each series split into one per facet panel, panel by panel: the same
-     * `name` (and so the same color and legend entry), its own `id` and `panel`,
-     * and only that panel's rows. A series with no rows in a panel has no part there.
-     */
-    static splitSeriesByPanel(series, panels, panelOf) {
-        const rowsByPanel = series.map((s) => {
-            const groups = new Map();
-            for (const row of s.data) {
-                const key = panelOf(row);
-                if (key === undefined)
-                    continue;
-                const bucket = groups.get(key);
-                if (bucket)
-                    bucket.push(row);
-                else
-                    groups.set(key, [row]);
-            }
-            return groups;
-        });
-        return panels.flatMap((panel) => series.flatMap((s, i) => {
-            const rows = rowsByPanel[i].get(panel.key);
-            if (!rows?.length)
-                return [];
-            return [
-                {
-                    ...s,
-                    id: FacetPhase.buildPanelSeriesId(panel.key, s.name),
-                    panel: panel.key,
-                    data: rows
-                }
-            ];
-        }));
-    }
-    /** A state narrowed to one panel's series, rows and processed rows. */
-    static narrowToPanel(state, panel) {
-        return FacetPhase.narrowToPanels(state, [panel]);
-    }
-    /** A state narrowed to some panels' series, rows and processed rows. */
-    static narrowToPanels(state, panels) {
-        const keep = new Set(panels);
-        const has = (panel) => keep.has(panel);
-        const resolvedSeries = state.resolvedSeries?.filter((s) => has(s.panel));
-        const { panelOf } = state;
-        return {
-            ...state,
-            resolvedSeries,
-            flat: panelOf
-                ? state.flat?.filter((row) => has(panelOf(row)))
-                : resolvedSeries?.flatMap((s) => s.data),
-            scopedGroups: state.scopedGroups?.filter((g) => has(g.panel)),
-            groupedSeries: state.groupedSeries?.filter((g) => has(g.series.panel)),
-            processedData: state.processedData && {
-                ...state.processedData,
-                data: state.processedData.data.filter((row) => has(row[PANEL_KEY]))
-            }
-        };
-    }
-    /**
-     * One facet panel's part of a run of the data phases over every panel: its
-     * series, rows, processed rows and markers, without the facet itself, ready
-     * for the phases each panel runs on its own.
-     */
-    static buildPanelState(state, panel) {
-        const narrowed = FacetPhase.narrowToPanel(state, panel);
-        const markers = state.markers?.flatMap((marker) => {
-            const own = marker;
-            if (own[PANEL_KEY] === undefined)
-                return [marker];
-            if (own[PANEL_KEY] !== panel)
-                return [];
-            const untagged = { ...own };
-            delete untagged[PANEL_KEY];
-            return [untagged];
-        });
-        const out = { ...narrowed, markers };
-        delete out.facet;
-        delete out.panels;
-        delete out.panelOf;
-        return out;
-    }
 }

package/dist/phases/hover/HoverPhase.d.ts

@@ -1,51 +1,19 @@
-import { PlotAxes } from '../data/PlotAxes';
-import type { HoverDisplayPoint, HoverPoint, HoverStrategy } from '../../types/layout/hover';
-import type { HoverConfig, PointMatchingStrategy, TooltipConfig } from '../../types/plots/props';
-import type { LegendState } from '../../layout/legend/LegendState.svelte';
+import type { HoverDisplayPoint, HoverPoint } from '../../types/layout/hover';
+import { LegendState } from '../../layout/legend/LegendState.svelte';
 import type { AxisPlotCtx, AxisPlotState, HoverPosition, HoverStageOptions, PhaseStage, ProcessedData } from '../../types/phases';
 type AnyAxisState = AxisPlotState<any, any, any, any>;
 /**
  * The "hover" phase every axis-based plot shares: what the pointer can match
- * (`hover`, the config `BasePlotLayout` mounts), the rows it draws and hovers
- * over (`hoverRows`) and where each sits (`hoverPosition`), from the kind's
- * options over everything placed before - the plot's `tooltip` and hover
- * markers, the tooltip phase's format, the legend in scope. A core only reads them.
- *
- * Every plot gets the same candidates: each processed row of a series the
- * legend shows, at its position, in its series' color - except a gap row (one
- * with no value, or filled in) and a row whose color falls outside the
- * legend's narrowed range.
+ * (`hover`), the rows it hovers over (`hoverRows`) and where each sits
+ * (`hoverPosition`). Candidates are the processed rows (or the kind's own
+ * hover `rows`) of the series the legend shows, except gap rows and rows
+ * outside the legend's narrowed range.
  */
 export declare class HoverPhase<TState extends AnyAxisState, TCtx extends AxisPlotCtx> implements PhaseStage<TState, TCtx> {
     #private;
     readonly phase: "hover";
     constructor(options?: HoverStageOptions<TState, TCtx>);
     run: (state: TState, ctx: TCtx) => TState;
-    /**
-     * The hover strategy a plot's axes ask for: along the axis that isn't
-     * measured (a bar's categories, a line's `x`), or one exact cell at a time
-     * when both axes hold categories.
-     */
-    static strategyOf(state: {
-        axes?: PlotAxes;
-    }): HoverStrategy;
-    /**
-     * A plot's `hover` config for `BasePlotLayout`: active whenever there's a
-     * tooltip or a hover marker, with the strategy and sync those two resolve to
-     * (the plot kind's own `defaultStrategy` when neither sets one). The tooltip
-     * reads as `format` unless it sets its own.
-     */
-    static buildHoverConfig<TRow extends Record<string, unknown>>(args: {
-        tooltip: TooltipConfig<TRow> | undefined;
-        format: (row: TRow) => string;
-        markers: {
-            type: string;
-        }[];
-        points: HoverPoint<TRow>[];
-        label: (row: TRow) => string;
-        defaultStrategy: HoverStrategy;
-        pointMatching?: PointMatchingStrategy;
-    }): HoverConfig<TRow>;
     /**
      * Hover candidates for a plot's own processed rows: each visible row at its
      * position (a stacked row's top, a bin's centre), in its series' color. A
@@ -64,10 +32,5 @@ export declare class HoverPhase<TState extends AnyAxisState, TCtx extends AxisPl
         /** Where a row sits, as is. Defaults to its processed position, with `y` as a number. */
         position?: HoverPosition;
     }): HoverPoint<TRow>[];
-    /** Whether a value sits within the legend's narrowed range; one with no value is never dimmed. */
-    static inRange(value: number | null | undefined, range: {
-        min: number;
-        max: number;
-    }): boolean;
 }
 export {};

package/dist/phases/hover/HoverPhase.js

@@ -1,18 +1,15 @@
-import { GAP_VALUE, SERIES_KEY, TransformsPhase } from '../transforms/TransformsPhase';
+import { ProcessedPositions } from '../transforms/ProcessedPositions';
+import { GAP_VALUE, SERIES_KEY } from '../transforms/TransformsPhase';
 import { HoverSettings } from '../../layout/hover/HoverSettings';
 import { PlotAxes } from '../data/PlotAxes';
 import { isGapValue } from '../../plots/utils/gaps';
+import { LegendState } from '../../layout/legend/LegendState.svelte';
 /**
  * The "hover" phase every axis-based plot shares: what the pointer can match
- * (`hover`, the config `BasePlotLayout` mounts), the rows it draws and hovers
- * over (`hoverRows`) and where each sits (`hoverPosition`), from the kind's
- * options over everything placed before - the plot's `tooltip` and hover
- * markers, the tooltip phase's format, the legend in scope. A core only reads them.
- *
- * Every plot gets the same candidates: each processed row of a series the
- * legend shows, at its position, in its series' color - except a gap row (one
- * with no value, or filled in) and a row whose color falls outside the
- * legend's narrowed range.
+ * (`hover`), the rows it hovers over (`hoverRows`) and where each sits
+ * (`hoverPosition`). Candidates are the processed rows (or the kind's own
+ * hover `rows`) of the series the legend shows, except gap rows and rows
+ * outside the legend's narrowed range.
  */
 export class HoverPhase {
     phase = 'hover';
@@ -24,7 +21,7 @@ export class HoverPhase {
         const options = this.#options;
         const valueAxis = PlotAxes.valueOf(state);
         const raw = options.position?.(state) ??
-            TransformsPhase.processedPosition(state.processedData, valueAxis);
+            ProcessedPositions.of(state.processedData, valueAxis);
         // A processed position reads as raw; the hover controller and the plot's
         // scales want its value as a number, unless that axis lays out categories.
         const position = options.position || state.axes?.isDiscrete(valueAxis)
@@ -32,8 +29,11 @@ export class HoverPhase {
             : { ...raw, [valueAxis]: (row) => Number(raw[valueAxis](row)) };
         const label = options.label?.(state) ??
             ((row) => String(state.channels[valueAxis].accessor(row)));
+        const processed = options.rows
+            ? { ...state.processedData, data: options.rows(state) }
+            : state.processedData;
         const points = HoverPhase.buildProcessedHoverPoints({
-            processed: state.processedData,
+            processed,
             colorFor: state.colorForSeries,
             legendInteraction: ctx.interaction?.legend,
             label: label,
@@ -42,13 +42,14 @@ export class HoverPhase {
             row: options.row?.(state),
             decorate: options.decorate?.(state, ctx)
         });
-        const hover = HoverPhase.buildHoverConfig({
+        const hover = HoverSettings.buildConfig({
             tooltip: state.tooltip,
-            format: state.tooltipFormat,
+            format: options.format?.(state) ?? state.tooltipFormat,
+            sort: options.sort?.(state) ?? state.tooltipSort,
             markers: state.authorMarkers ?? [],
             points: points,
             label: label,
-            defaultStrategy: options.strategy ?? HoverPhase.strategyOf(state),
+            defaultStrategy: options.strategy ?? HoverSettings.strategyOf(state.axes),
             pointMatching: options.pointMatching
         });
         const hitAreas = options.hitAreas?.(state, hover, ctx) ?? [];
@@ -56,42 +57,10 @@ export class HoverPhase {
             ...state,
             hover,
             hoverPosition: position,
-            hoverRows: state.processedData.data,
+            hoverRows: processed.data,
             ...(hitAreas.length > 0 ? { markers: [...(state.markers ?? []), ...hitAreas] } : {})
         };
     };
-    /**
-     * The hover strategy a plot's axes ask for: along the axis that isn't
-     * measured (a bar's categories, a line's `x`), or one exact cell at a time
-     * when both axes hold categories.
-     */
-    static strategyOf(state) {
-        const { axes } = state;
-        if (!axes)
-            return 'x';
-        if (axes.isDiscrete('x') && axes.isDiscrete('y'))
-            return 'punctual';
-        return PlotAxes.other(PlotAxes.valueOf(state));
-    }
-    /**
-     * A plot's `hover` config for `BasePlotLayout`: active whenever there's a
-     * tooltip or a hover marker, with the strategy and sync those two resolve to
-     * (the plot kind's own `defaultStrategy` when neither sets one). The tooltip
-     * reads as `format` unless it sets its own.
-     */
-    static buildHoverConfig(args) {
-        const { tooltip, format, markers, points, label, defaultStrategy, pointMatching } = args;
-        const settings = new HoverSettings(tooltip, markers, defaultStrategy);
-        return {
-            active: settings.active,
-            points,
-            label,
-            strategy: settings.strategy,
-            sync: settings.sync,
-            tooltip: tooltip && { ...tooltip, format: tooltip.format ?? format },
-            ...(pointMatching ? { pointMatching } : {})
-        };
-    }
     /**
      * Hover candidates for a plot's own processed rows: each visible row at its
      * position (a stacked row's top, a bin's centre), in its series' color. A
@@ -99,7 +68,7 @@ export class HoverPhase {
      */
     static buildProcessedHoverPoints(args) {
         const { processed, colorFor, legendInteraction, label, include, row: rowOf, decorate } = args;
-        const processedPosition = TransformsPhase.processedPosition(processed);
+        const processedPosition = ProcessedPositions.of(processed);
         const position = args.position ?? {
             x: processedPosition.x,
             y: (row) => Number(processedPosition.y(row))
@@ -134,11 +103,7 @@ export class HoverPhase {
         return (row) => {
             if (isGapValue(position[valueAxis](row)) || row[GAP_VALUE] !== undefined)
                 return false;
-            return !range || !color || HoverPhase.inRange(Number(color(row)), range);
+            return !range || !color || LegendState.inRange(Number(color(row)), range);
         };
     }
-    /** Whether a value sits within the legend's narrowed range; one with no value is never dimmed. */
-    static inRange(value, range) {
-        return value == null || (value >= range.min && value <= range.max);
-    }
 }

package/dist/phases/mapping/MappingPhase.d.ts

@@ -4,7 +4,7 @@ type AnyAxisState = AxisPlotState<any, any, any, any>;
  * 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`.
  */