@fundar/data-chart-telling 1.17.0 → 1.18.0

package/dist/phases/context/RowContext.js

@@ -0,0 +1,95 @@
+import { SERIES_ID_KEY, SERIES_KEY } from '../transforms/TransformsPhase';
+import { ProcessedPositions } from '../transforms/ProcessedPositions';
+import { PlotAxes } from '../data/PlotAxes';
+import { resolveAccessor } from '../../utils/accessors';
+import { seriesIdOf } from '../../utils/grouping';
+/** Where a row's context is kept on it: under a symbol, which survives the copies svelteplot makes of a row. */
+const KEY = Symbol('dct-row-context');
+/**
+ * The context of the rows a plot draws ({@link PlotRowContext}): worked out once per row by the "context" phase,
+ * kept on the row itself, and read back from it - or from any copy of it - with {@link of}.
+ */
+export class RowContext {
+    /**
+     * What the plot knows of `row`: its series, where it sits, the value it shows and whatever its kind works out
+     * for it, with the row itself. A row no plot drew reads as its series alone.
+     */
+    static of(row) {
+        if (row == null || typeof row !== 'object')
+            return {};
+        const record = row;
+        const own = record[KEY];
+        if (own)
+            return { ...own, row };
+        const series = record[SERIES_KEY];
+        return { ...(typeof series === 'string' ? { series } : {}), row };
+    }
+    /** Keeps `context` on `row`, for {@link of} to read back. */
+    static tag(row, context) {
+        row[KEY] = context;
+    }
+    /** Whether `row` carries a context already. */
+    static has(row) {
+        return row != null && typeof row === 'object' && KEY in row;
+    }
+    /** A reader of the rows of `state`: the context each carries, else the shared one, for a row no phase tagged. */
+    static reader(state) {
+        let shared;
+        return (row) => {
+            if (RowContext.has(row))
+                return RowContext.of(row);
+            shared ??= RowContext.shared(state);
+            return { ...shared(row), row };
+        };
+    }
+    /**
+     * The context every plot gives a processed row: its series; its `x` and `y` - each its series' own value
+     * (a stacked row's own, not the running total), else where the transforms put it (a density's estimate, a
+     * bin's centre); and its value on the plot's value axis, when that is a number.
+     */
+    static shared(state) {
+        const processed = state.processedData;
+        if (!processed)
+            return () => ({});
+        const valueAxis = PlotAxes.valueOf(state);
+        const placed = ProcessedPositions.of(processed, valueAxis);
+        const x = RowContext.#along(state, 'x', RowContext.#stacked(processed, 'x') ?? placed.x);
+        const y = RowContext.#along(state, 'y', RowContext.#stacked(processed, 'y') ?? placed.y);
+        return (row) => {
+            const series = row[SERIES_KEY];
+            const at = { x: x(row), y: y(row) };
+            const raw = at[valueAxis];
+            const value = raw instanceof Date || raw === null || raw === '' ? NaN : Number(raw);
+            return {
+                ...(typeof series === 'string' ? { series } : {}),
+                ...at,
+                ...(Number.isFinite(value) ? { value } : {})
+            };
+        };
+    }
+    /** A stacked row's own value along `axis` - its span, not the running total - or `undefined` with no stack there. */
+    static #stacked(processed, axis) {
+        const from = processed.channels[`${axis}1`];
+        const to = processed.channels[`${axis}2`];
+        const stack = axis === 'x' ? 'stackX' : 'stackY';
+        if (from === undefined || to === undefined)
+            return undefined;
+        if (!processed.transforms.some((t) => t.type === stack))
+            return undefined;
+        const low = resolveAccessor(from);
+        const high = resolveAccessor(to);
+        return (row) => Number(high(row)) - Number(low(row));
+    }
+    /** A row's value along `axis`: its series' own channel, else `placed`. */
+    static #along(state, axis, placed) {
+        const bySeries = new Map((state.resolvedSeries ?? []).flatMap((s) => {
+            const accessor = s[axis];
+            return accessor === undefined ? [] : [[seriesIdOf(s), resolveAccessor(accessor)]];
+        }));
+        return (row) => {
+            const own = bySeries.get(String(row[SERIES_ID_KEY]));
+            const value = own?.(row);
+            return value === undefined ? placed(row) : value;
+        };
+    }
+}

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

@@ -1,4 +1,4 @@
-import type { AxisPlotState, AxisPlotCtx, DataStageOptions, PhaseStage } from '../../types/phases';
+import type { AxisPlotState, AxisPlotEnv, DataStageOptions, PhaseStage } from '../../types/phases';
 type AnyAxisState = AxisPlotState<any, any, any, any>;
 /**
  * The "data" phase every axis-based plot shares: its series (from `series`,
@@ -10,10 +10,10 @@ type AnyAxisState = AxisPlotState<any, any, any, any>;
  * Colors and axes come from every series, before any is omitted or split by
  * facet panel, so they stay put and every panel agrees.
  */
-export declare class DataPhase<TState extends AnyAxisState, TCtx extends AxisPlotCtx> implements PhaseStage<TState, TCtx> {
+export declare class DataPhase<TState extends AnyAxisState, TEnv extends AxisPlotEnv> implements PhaseStage<TState, TEnv> {
     #private;
     readonly phase: "data";
-    constructor(options?: DataStageOptions<TState, TCtx>);
-    run: (state: TState, ctx: TCtx) => TState;
+    constructor(options?: DataStageOptions<TState, TEnv>);
+    run: (state: TState, env: TEnv) => TState;
 }
 export {};

package/dist/phases/data/DataPhase.js

@@ -22,7 +22,7 @@ export class DataPhase {
     constructor(options = {}) {
         this.#options = options;
     }
-    run = (state, ctx) => {
+    run = (state, env) => {
         const options = this.#options;
         const { series, data, segments, scales } = state;
         const { connect = true, color: segmentColor } = options.segments ?? {};
@@ -35,8 +35,8 @@ export class DataPhase {
             given: { x: state.x !== undefined, y: state.y !== undefined },
             discrete: options.discreteAxes
         });
-        const seriesColors = ColorRamp.resolve(scales.color, (options.colorOrder ? options.colorOrder(fullSeries) : fullSeries).map((s) => s.name), ctx.cfg.palette);
-        const colorForPath = series ? undefined : DataPhase.#buildPathColors(state, ctx);
+        const seriesColors = ColorRamp.resolve(scales.color, (options.colorOrder ? options.colorOrder(fullSeries) : fullSeries).map((s) => s.name), env.cfg.palette);
+        const colorForPath = series ? undefined : DataPhase.#buildPathColors(state, env);
         // A plot that splits its series by every level colors each one by its path; a nested one by its outermost.
         const colorForSeries = colorForPath && !options.nested
             ? DataPhase.#byPath(state, colorForPath, seriesColors)
@@ -44,7 +44,7 @@ export class DataPhase {
         const panelSeries = state.panels && state.panelOf && !series
             ? FacetPanels.splitSeries(fullSeries, state.panels, state.panelOf)
             : fullSeries;
-        const legend = ctx.interaction?.legend;
+        const legend = env.interaction?.legend;
         const resolvedSeries = legend?.withoutOmitted(panelSeries) ?? panelSeries;
         const removedSeries = legend?.removed(panelSeries);
         const baseFor = BasicStyles.of(state.styles, options.segments?.base);
@@ -75,14 +75,14 @@ export class DataPhase {
             ...(colorForPath ? { colorForPath } : {}),
             ...(gapFillMaps ? { gapFillMaps } : {})
         };
-        return options.extend ? options.extend(next, ctx) : next;
+        return options.extend ? options.extend(next, env) : next;
     };
     /**
      * The color of a path of the plot's `grouping` levels, when `scales.color.depth` reaches past the outermost
      * one: each outermost value its categorical color, and every path down to `depth` a tone of it (see
      * {@link ColorTones.hierarchy}). `undefined` for a grouping of one level, or a depth of 1.
      */
-    static #buildPathColors(state, ctx) {
+    static #buildPathColors(state, env) {
         const depth = state.scales.color?.depth ?? 1;
         const rows = state.data ?? [];
         const levels = Grouping.levels(state.grouping, rows).map((level) => resolveAccessor(level));
@@ -90,7 +90,7 @@ export class DataPhase {
             return undefined;
         const paths = rows.map((row) => levels.map((read) => String(read(row))));
         const outermost = [...new Set(paths.map((path) => path[0]))];
-        const colorOf = ColorRamp.resolve(state.scales.color, outermost, ctx.cfg.palette);
+        const colorOf = ColorRamp.resolve(state.scales.color, outermost, env.cfg.palette);
         return ColorTones.hierarchy(paths, depth, (value) => colorOf(value));
     }
     /** A series' color as the color of its path - its name is the key its levels make together. */

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

@@ -1,6 +1,6 @@
 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';
+import type { AxisPlotEnv, 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
@@ -9,15 +9,16 @@ type AnyAxisState = AxisPlotState<any, any, any, any>;
  * 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> {
+export declare class HoverPhase<TState extends AnyAxisState, TEnv extends AxisPlotEnv> implements PhaseStage<TState, TEnv> {
     #private;
     readonly phase: "hover";
-    constructor(options?: HoverStageOptions<TState, TCtx>);
-    run: (state: TState, ctx: TCtx) => TState;
+    constructor(options?: HoverStageOptions<TState, TEnv>);
+    run: (state: TState, env: TEnv) => TState;
     /**
      * 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
-     * series the legend turned off is left out, as is any row `include` rejects.
+     * series the legend hides, omits or rescales away is left out (a dimmed one
+     * stays), as is any row `include` rejects.
      */
     static buildProcessedHoverPoints<TRow extends Record<string, unknown>>(args: {
         processed: ProcessedData;
@@ -25,8 +26,6 @@ export declare class HoverPhase<TState extends AnyAxisState, TCtx extends AxisPl
         legendInteraction?: LegendState | null;
         label: (row: TRow) => string;
         include?: (row: TRow) => boolean;
-        /** The row a hovered point reads as, e.g. with derived fields added. Defaults to the processed row. */
-        row?: (row: TRow) => TRow;
         /** Fields to add to (or replace on) each point. */
         decorate?: (row: TRow) => Partial<HoverDisplayPoint>;
         /** Where a row sits, as is. Defaults to its processed position, with `y` as a number. */

package/dist/phases/hover/HoverPhase.js

@@ -1,10 +1,12 @@
 import { ProcessedPositions } from '../transforms/ProcessedPositions';
 import { GAP_VALUE, SERIES_KEY } from '../transforms/TransformsPhase';
 import { HoverSettings } from '../../layout/hover/HoverSettings';
+import { RowContext } from '../context/RowContext';
 import { PlotAxes } from '../data/PlotAxes';
 import { NumberFormat } from '../../utils/NumberFormat';
 import { isGapValue } from '../../plots/utils/gaps';
 import { LegendState } from '../../layout/legend/LegendState.svelte';
+import { HoverDefaults } from '../../layout/hover/HoverDefaults';
 /**
  * The "hover" phase every axis-based plot shares: what the pointer can match
  * (`hover`), the rows it hovers over (`hoverRows`) and where each sits
@@ -18,7 +20,7 @@ export class HoverPhase {
     constructor(options = {}) {
         this.#options = options;
     }
-    run = (state, ctx) => {
+    run = (state, env) => {
         const options = this.#options;
         const valueAxis = PlotAxes.valueOf(state);
         const raw = options.position?.(state) ??
@@ -28,20 +30,23 @@ export class HoverPhase {
         const position = options.position || state.axes?.isDiscrete(valueAxis)
             ? raw
             : { ...raw, [valueAxis]: (row) => Number(raw[valueAxis](row)) };
+        // A row's label is the value its context gives it, else its value channel's.
         const label = options.label?.(state) ??
-            ((row) => String(state.channels[valueAxis].accessor(row)));
+            ((row) => {
+                const { value } = RowContext.of(row);
+                return String(value ?? state.channels[valueAxis].accessor(row));
+            });
         const processed = options.rows
             ? { ...state.processedData, data: options.rows(state) }
             : state.processedData;
         const points = HoverPhase.buildProcessedHoverPoints({
             processed,
             colorFor: state.colorForSeries,
-            legendInteraction: ctx.interaction?.legend,
+            legendInteraction: env.interaction?.legend,
             label: label,
             position,
-            include: HoverPhase.#hoverable(state, ctx, raw, valueAxis),
-            row: options.row?.(state),
-            decorate: options.decorate?.(state, ctx)
+            include: HoverPhase.#hoverable(state, env, raw, valueAxis),
+            decorate: options.decorate?.(state, env)
         });
         const hover = HoverSettings.buildConfig({
             tooltip: state.tooltip,
@@ -52,13 +57,18 @@ export class HoverPhase {
             label: label,
             defaultStrategy: options.strategy ?? HoverSettings.strategyOf(state.axes),
             pointMatching: options.pointMatching,
-            number: NumberFormat.of(NumberFormat.displayOf(state.tooltip), ctx.cfg),
-            context: HoverPhase.#contextOf(options.context?.(state))
+            number: NumberFormat.of(NumberFormat.displayOf(state.tooltip), env.cfg)
         });
-        const hitAreas = options.hitAreas?.(state, hover, ctx) ?? [];
+        const hitAreas = options.hitAreas?.(state, hover, env) ?? [];
+        const own = options.marker?.(state, env);
+        const look = typeof own === 'function'
+            ? own
+            : own
+                ? () => own
+                : (strategy) => HoverDefaults.of(strategy, hover.crosshair);
         return {
             ...state,
-            hover,
+            hover: { ...hover, look },
             hoverPosition: position,
             hoverRows: processed.data,
             ...(hitAreas.length > 0 ? { markers: [...(state.markers ?? []), ...hitAreas] } : {})
@@ -67,10 +77,11 @@ export class HoverPhase {
     /**
      * 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
-     * series the legend turned off is left out, as is any row `include` rejects.
+     * series the legend hides, omits or rescales away is left out (a dimmed one
+     * stays), as is any row `include` rejects.
      */
     static buildProcessedHoverPoints(args) {
-        const { processed, colorFor, legendInteraction, label, include, row: rowOf, decorate } = args;
+        const { processed, colorFor, legendInteraction, label, include, decorate } = args;
         const processedPosition = ProcessedPositions.of(processed);
         const position = args.position ?? {
             x: processedPosition.x,
@@ -79,7 +90,7 @@ export class HoverPhase {
         const x = position.x;
         const y = position.y;
         return processed.data
-            .filter((d) => !legendInteraction?.isOff(d[SERIES_KEY]))
+            .filter((d) => !legendInteraction?.isUnhoverable(d[SERIES_KEY]))
             .filter((d) => !include || include(d))
             .map((d) => {
             const row = d;
@@ -87,7 +98,8 @@ export class HoverPhase {
             return {
                 x: x(d),
                 y: y(d),
-                row: rowOf ? rowOf(row) : row,
+                row,
+                context: RowContext.of(row),
                 label: label(row),
                 series: seriesName,
                 color: colorFor(seriesName),
@@ -95,20 +107,13 @@ export class HoverPhase {
             };
         });
     }
-    /** What the plot knows of a hovered row: its series, and whatever its kind adds. */
-    static #contextOf(kind) {
-        return (row) => {
-            const series = row[SERIES_KEY];
-            return { ...(typeof series === 'string' ? { series } : {}), ...kind?.(row) };
-        };
-    }
     /**
      * Which processed rows can be hovered: not a gap (no value where it sits, or
      * filled in by `styles.gaps`), and, while the legend narrows a continuous
      * color to a range, not outside it. A dimmed row stays drawn, never matched.
      */
-    static #hoverable(state, ctx, position, valueAxis) {
-        const range = ctx.interaction?.legend?.range;
+    static #hoverable(state, env, position, valueAxis) {
+        const range = env.interaction?.legend?.range;
         const color = state.channels?.color?.accessor;
         return (row) => {
             if (isGapValue(position[valueAxis](row)) || row[GAP_VALUE] !== undefined)

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

@@ -1,4 +1,4 @@
-import type { AxisPlotState, AxisPlotCtx, MappingStageOptions, PhaseStage } from '../../types/phases';
+import type { AxisPlotState, AxisPlotEnv, MappingStageOptions, PhaseStage } from '../../types/phases';
 type AnyAxisState = AxisPlotState<any, any, any, any>;
 /**
  * The "mapping" phase every axis-based plot shares: every channel resolved to
@@ -8,10 +8,10 @@ type AnyAxisState = AxisPlotState<any, any, any, any>;
  * 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`.
  */
-export declare class MappingPhase<TState extends AnyAxisState, TCtx extends AxisPlotCtx> implements PhaseStage<TState, TCtx> {
+export declare class MappingPhase<TState extends AnyAxisState, TEnv extends AxisPlotEnv> implements PhaseStage<TState, TEnv> {
     #private;
     readonly phase: "mapping";
-    constructor(options?: MappingStageOptions<TState, TCtx>);
-    run: (state: TState, ctx: TCtx) => TState;
+    constructor(options?: MappingStageOptions<TState, TEnv>);
+    run: (state: TState, env: TEnv) => TState;
 }
 export {};

package/dist/phases/mapping/MappingPhase.js

@@ -13,7 +13,7 @@ export class MappingPhase {
     constructor(options = {}) {
         this.#options = options;
     }
-    run = (state, ctx) => {
+    run = (state, env) => {
         const first = state.resolvedSeries?.[0];
         const identity = { accessor: (d) => d };
         const size = (value) => typeof value === 'number' ? value : MappingPhase.#channel(value);
@@ -29,7 +29,7 @@ export class MappingPhase {
             value: MappingPhase.#channel(state.value)
         };
         const next = { ...state, channels };
-        return this.#options.extend ? this.#options.extend(next, ctx) : next;
+        return this.#options.extend ? this.#options.extend(next, env) : next;
     };
     /** A channel prop resolved to a row accessor, keeping it as `source`, or left out when unset. */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/phases/markers/MarkerStyles.d.ts

@@ -15,4 +15,12 @@ export declare class MarkerStyles {
         cfg?: PlotStylesConfig;
         rows?: unknown[];
     }): T[];
+    /**
+     * `marker` resolved again after its styles changed (as the hover restyles a shape): a label written in the color
+     * that read best on the shape's old one reads best on its new one.
+     */
+    static restyle<T>(marker: T, plot?: {
+        cfg?: PlotStylesConfig;
+        rows?: unknown[];
+    }): T;
 }

package/dist/phases/markers/MarkerStyles.js

@@ -17,6 +17,8 @@ export class MarkerStyles {
     };
     /** The style fields that take a dash pattern. */
     static #DASH_KEYS = new Set(['strokeDasharray', 'dotStrokeDasharray']);
+    /** The label colors this class chose for a shape's color, which a restyled shape chooses again. */
+    static #contrasts = new WeakSet();
     /** Fields that hold rows rather than config, which are never walked. */
     static #ROW_KEYS = new Set(['data', 'features']);
     /**
@@ -26,6 +28,18 @@ export class MarkerStyles {
     static resolveAll(markers, plot = {}) {
         return markers.map((marker) => MarkerStyles.#contrasted(MarkerStyles.#walk(marker), plot));
     }
+    /**
+     * `marker` resolved again after its styles changed (as the hover restyles a shape): a label written in the color
+     * that read best on the shape's old one reads best on its new one.
+     */
+    static restyle(marker, plot = {}) {
+        const label = marker.label;
+        const fill = label?.styles?.fill;
+        const fresh = typeof fill === 'function' && MarkerStyles.#contrasts.has(fill)
+            ? { ...marker, label: { ...label, styles: { ...label.styles, fill: undefined } } }
+            : marker;
+        return MarkerStyles.resolveAll([fresh], plot)[0];
+    }
     /** The marker with its label inside its shape written in the candidate that reads best on each row's color. */
     static #contrasted(marker, plot) {
         const { cfg } = plot;
@@ -48,6 +62,7 @@ export class MarkerStyles {
             const seen = CssColor.composite(color, opacityOf(row), cfg.background);
             return CssColor.contrastText(seen, candidates);
         };
+        MarkerStyles.#contrasts.add(fill);
         return { ...marker, label: { ...label, styles: { ...label.styles, fill } } };
     }
     /** The opacity each row's shape is drawn with: a number, the field of the rows a string names, a function of the row. */

package/dist/phases/markers/MarkersPhase.d.ts

@@ -1,4 +1,4 @@
-import type { AxisPlotCtx, AxisPlotState, MarkersStageOptions, PhaseStage } from '../../types/phases';
+import type { AxisPlotEnv, AxisPlotState, MarkersStageOptions, PhaseStage } from '../../types/phases';
 /**
  * The shared "markers" phase: everything the plot draws, bottom to top - the
  * plot kind's own marks, then what the "statistics" phase left in
@@ -6,9 +6,9 @@ import type { AxisPlotCtx, AxisPlotState, MarkersStageOptions, PhaseStage } from
  * value labels when `styles.values.show` turns them on, each with what every
  * label shares ({@link ValueLabels.hooks}), and every style as svelteplot reads it ({@link MarkerStyles}).
  */
-export declare class MarkersPhase<TState extends AxisPlotState<any, any, any, any>, TCtx extends AxisPlotCtx> implements PhaseStage<TState, TCtx> {
+export declare class MarkersPhase<TState extends AxisPlotState<any, any, any, any>, TEnv extends AxisPlotEnv> implements PhaseStage<TState, TEnv> {
     #private;
     readonly phase: "markers";
-    constructor(options: MarkersStageOptions<TState, TCtx>);
-    run: (state: TState, ctx: TCtx) => TState;
+    constructor(options: MarkersStageOptions<TState, TEnv>);
+    run: (state: TState, env: TEnv) => TState;
 }

package/dist/phases/markers/MarkersPhase.js

@@ -13,18 +13,18 @@ export class MarkersPhase {
     constructor(options) {
         this.#options = options;
     }
-    run = (state, ctx) => {
+    run = (state, env) => {
         const options = this.#options;
         const labels = state.valueLabels;
         const valueLabels = labels?.show && options.valueLabels
-            ? options.valueLabels(labels, state, ctx).map((marker) => {
-                const { styles, ...hooks } = labels.hooks(ctx);
+            ? options.valueLabels(labels, state, env).map((marker) => {
+                const { styles, ...hooks } = labels.hooks(env);
                 return { ...hooks, ...marker, styles: { ...styles, ...marker.styles } };
             })
             : [];
         return {
             ...state,
-            markers: MarkerStyles.resolveAll(MarkerChannels.inheritPosition(MarkerChannels.inheritAll([...options.marks(state, ctx), ...(state.markers ?? []), ...valueLabels], state.scales), state.processedData), { cfg: ctx.cfg, rows: state.processedData?.data })
+            markers: MarkerStyles.resolveAll(MarkerChannels.inheritPosition(MarkerChannels.inheritAll([...options.marks(state, env), ...(state.markers ?? []), ...valueLabels], state.scales), state.processedData), { cfg: env.cfg, rows: state.processedData?.data })
         };
     };
 }

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, ScalesStageOptions } from '../../types/phases';
+import type { AxisPlotState, AxisPlotEnv, PhaseStage, ScalesStageOptions } from '../../types/phases';
 type AnyAxisState = AxisPlotState<any, any, any, any>;
 /**
  * The shared "scales" phase. Each axis the kind lays out as categories
@@ -10,10 +10,10 @@ type AnyAxisState = AxisPlotState<any, any, any, any>;
  * transforms gave the rows - from zero on the axes `zero` names. The author's
  * `scales` always win, and a kind adds its own on top (`defaults`, `fit`, `extend`).
  */
-export declare class ScalesPhase<TState extends AnyAxisState, TCtx extends AxisPlotCtx> implements PhaseStage<TState, TCtx> {
+export declare class ScalesPhase<TState extends AnyAxisState, TEnv extends AxisPlotEnv> implements PhaseStage<TState, TEnv> {
     #private;
     readonly phase: "scales";
-    constructor(options?: ScalesStageOptions<TState, TCtx>);
+    constructor(options?: ScalesStageOptions<TState, TEnv>);
     /** The axes whose marks grow from zero, in this state. */
     zeroAxes(state: {
         axes?: PlotAxes;
@@ -24,6 +24,6 @@ export declare class ScalesPhase<TState extends AnyAxisState, TCtx extends AxisP
     }): AxisChannelName[];
     /** Whether the kind keeps its categories in the order the data gives them. */
     get keepsDataOrder(): boolean;
-    run: (state: TState, ctx: TCtx) => TState;
+    run: (state: TState, env: TEnv) => TState;
 }
 export {};

package/dist/phases/scales/ScalesPhase.js

@@ -44,10 +44,10 @@ export class ScalesPhase {
     get keepsDataOrder() {
         return this.#options.bandOrder === 'data';
     }
-    run = (state, ctx) => {
+    run = (state, env) => {
         const options = this.#options;
         const { axes, processedData, markers = [] } = state;
-        const defaults = options.defaults?.(state, ctx) ?? {};
+        const defaults = options.defaults?.(state, env) ?? {};
         const symmetric = new Set(this.symmetricAxes(state));
         const zero = new Set(this.zeroAxes(state));
         const scales = { ...state.scales };
@@ -72,7 +72,7 @@ export class ScalesPhase {
                 scales[axis] = { ...scales[axis], domain: [-reach, reach] };
             }
         }
-        const fitted = options.fit?.({ ...state, scales }, ctx) ?? {};
+        const fitted = options.fit?.({ ...state, scales }, env) ?? {};
         const fittedAxes = [];
         for (const axis of AXES) {
             if (!fitted[axis])
@@ -111,7 +111,7 @@ export class ScalesPhase {
                 : { ...author, domain: [lo, hi], nice: author?.nice ?? true };
         }
         const next = { ...state, scales, ...(fittedAxes.length ? { fittedAxes } : {}) };
-        return options.extend ? options.extend(next, ctx) : next;
+        return options.extend ? options.extend(next, env) : 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, state, axis) {

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

@@ -30,11 +30,11 @@ type SharedScalesState = FacetStageState & {
  * can't happen there. Without options, a kind still shares its domains: it just
  * has no bands and nothing that starts from zero.
  */
-export declare class SharedScalesPhase<TState extends SharedScalesState, TCtx> implements PhaseStage<TState, TCtx> {
+export declare class SharedScalesPhase<TState extends SharedScalesState, TEnv> implements PhaseStage<TState, TEnv> {
     #private;
     readonly phase: "sharedScales";
     constructor(options: SharedScalesOptions | undefined, scales?: ScalesPhase<any, any>);
-    run: (state: TState, ctx: TCtx) => TState;
+    run: (state: TState, env: TEnv) => TState;
     /**
      * One axis' domain over some slices: sorted values on a band axis, `[min, max]`
      * otherwise, or `undefined`. A numeric extent is niced here, once, so every

package/dist/phases/sharedScales/SharedScalesPhase.js

@@ -34,7 +34,7 @@ export class SharedScalesPhase {
         this.#scales = scales;
         this.#kindScales = new Pipeline([scales]);
     }
-    run = (state, ctx) => {
+    run = (state, env) => {
         const facet = state.facet;
         const panels = facet ? (state.panels ?? []) : [];
         // A symmetric axis has no domain but the one the kind's "scales" phase gives it.
@@ -54,7 +54,7 @@ export class SharedScalesPhase {
         const domainOver = (channel, members) => {
             if (fromPhase.has(channel)) {
                 const scoped = members ? FacetPanels.narrowToPanels(state, members) : state;
-                const scales = this.#kindScales.run(scoped, ctx).scales;
+                const scales = this.#kindScales.run(scoped, env).scales;
                 const domain = scales?.[channel]?.domain;
                 return domain === undefined ? undefined : { domain };
             }

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

@@ -35,14 +35,5 @@ export declare class MarkerGrouping {
         color?: unknown;
         defaultColor?: string;
     }): TMarker[];
-    /**
-     * Gives a scoped hover marker its series color through its own `dot` and
-     * `text` styles, the way `withSeriesColor` does for other markers. A style the
-     * marker sets itself keeps its own color.
-     */
-    static withHoverSeriesColor<T extends {
-        dot?: object;
-        text?: object;
-    }>(marker: T, color: string | undefined): T;
 }
 export {};

package/dist/phases/statistics/MarkerGrouping.js

@@ -94,20 +94,4 @@ export class MarkerGrouping {
             return Object.keys(updates).length ? { ...m, ...updates } : marker;
         });
     }
-    /**
-     * Gives a scoped hover marker its series color through its own `dot` and
-     * `text` styles, the way `withSeriesColor` does for other markers. A style the
-     * marker sets itself keeps its own color.
-     */
-    static withHoverSeriesColor(marker, color) {
-        if (!color)
-            return marker;
-        const dot = (marker.dot ?? {});
-        const text = (marker.text ?? {});
-        return {
-            ...marker,
-            dot: { ...dot, dotFill: dot.dotFill ?? color, dotStroke: dot.dotStroke ?? color },
-            text: { ...text, fill: text.fill ?? color }
-        };
-    }
 }

package/dist/phases/styles/StylesPhase.d.ts

@@ -1,13 +1,13 @@
-import type { AxisPlotState, AxisPlotCtx, PhaseStage } from '../../types/phases';
+import type { AxisPlotState, AxisPlotEnv, PhaseStage } from '../../types/phases';
 import type { StylesStageOptions } from '../../types/phases/styles/phase';
 /**
  * The shared "styles" phase: resolves the plot's `styles` against the plot
  * kind's own defaults - its value labels (`valueLabels`), with how far they
  * are expected to reach out, which its margins start from.
  */
-export declare class StylesPhase<TState extends AxisPlotState<any, any, any, any>, TCtx extends AxisPlotCtx> implements PhaseStage<TState, TCtx> {
+export declare class StylesPhase<TState extends AxisPlotState<any, any, any, any>, TEnv extends AxisPlotEnv> implements PhaseStage<TState, TEnv> {
     #private;
     readonly phase: "styles";
     constructor(options?: StylesStageOptions<TState>);
-    run: (state: TState, ctx: TCtx) => TState;
+    run: (state: TState, env: TEnv) => TState;
 }

package/dist/phases/styles/StylesPhase.js

@@ -10,8 +10,8 @@ export class StylesPhase {
     constructor(options = {}) {
         this.#options = options;
     }
-    run = (state, ctx) => ({
+    run = (state, env) => ({
         ...state,
-        valueLabels: ValueLabels.build(state.values, ctx.cfg, this.#options.values ?? {}, state)
+        valueLabels: ValueLabels.build(state.values, env.cfg, this.#options.values ?? {}, state)
     });
 }