@fundar/data-chart-telling 1.17.0 → 1.19.0

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

@@ -1,6 +1,7 @@
 import { MarkerChannels } from '../../markers/utils/MarkerChannels';
 import { RowStyle } from '../../markers/utils/RowStyle';
 import { CssColor } from '../../utils/color/CssColor';
+import { MarkerLabels } from '../../markers/labels/MarkerLabels';
 /**
  * A plot's markers with their styles as svelteplot reads them, before any is drawn: a named line style
  * (`strokeDasharray: 'dashed'`) is the SVG dash pattern it stands for, wherever in a marker's config it is
@@ -17,6 +18,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,21 +29,35 @@ export class MarkerStyles {
     static resolveAll(markers, plot = {}) {
         return markers.map((marker) => MarkerStyles.#contrasted(MarkerStyles.#walk(marker), plot));
     }
-    /** The marker with its label inside its shape written in the candidate that reads best on each row's color. */
+    /**
+     * `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 fresh = MarkerLabels.map(marker, (label) => {
+            const fill = label.styles?.fill;
+            return typeof fill === 'function' && MarkerStyles.#contrasts.has(fill)
+                ? { ...label, styles: { ...label.styles, fill: undefined } }
+                : label;
+        });
+        return MarkerStyles.resolveAll([fresh], plot)[0];
+    }
+    /** Writes each label on its shape in the color that reads best on it. */
     static #contrasted(marker, plot) {
         const { cfg } = plot;
         if (!cfg || !MarkerStyles.#isPlain(marker))
             return marker;
-        const label = marker.label;
-        if (!MarkerStyles.#isPlain(label) || label.outside || label.styles?.fill !== undefined) {
+        const unset = (label) => MarkerStyles.#isPlain(label) &&
+            MarkerLabels.isOnShape(marker, label) &&
+            label.styles?.fill === undefined;
+        if (!MarkerLabels.list(marker).some(unset))
             return marker;
-        }
         const colorOf = MarkerStyles.#shapeColor(marker, marker.data ?? plot.rows ?? [], cfg);
         if (!colorOf)
             return marker;
         const candidates = cfg.text.label.contrast;
         const opacityOf = MarkerStyles.#opacity(marker.styles?.fillOpacity);
-        // What the label is read on: the shape's color, blended with the plot's background as far as it is see-through.
+        // The shape's color as seen: blended with the background by its opacity.
         const fill = (row) => {
             const color = colorOf(row);
             if (!color)
@@ -48,7 +65,8 @@ export class MarkerStyles {
             const seen = CssColor.composite(color, opacityOf(row), cfg.background);
             return CssColor.contrastText(seen, candidates);
         };
-        return { ...marker, label: { ...label, styles: { ...label.styles, fill } } };
+        MarkerStyles.#contrasts.add(fill);
+        return MarkerLabels.map(marker, (label) => unset(label) ? { ...label, styles: { ...label.styles, fill } } : label);
     }
     /** The opacity each row's shape is drawn with: a number, the field of the rows a string names, a function of the row. */
     static #opacity(style) {

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

@@ -1,14 +1,13 @@
-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
- * `state.markers` (the author's markers and the plot's statistics), then its
- * 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}).
+ * `state.markers` (the author's markers and the plot's statistics), then the
+ * `'point'` labels of all of them, 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

@@ -1,11 +1,12 @@
 import { MarkerChannels } from '../../markers/utils/MarkerChannels';
 import { MarkerStyles } from './MarkerStyles';
+import { MarkerLabels } from '../../markers/labels/MarkerLabels';
+import { PlotAxes } from '../data/PlotAxes';
 /**
  * The shared "markers" phase: everything the plot draws, bottom to top - the
  * plot kind's own marks, then what the "statistics" phase left in
- * `state.markers` (the author's markers and the plot's statistics), then its
- * 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}).
+ * `state.markers` (the author's markers and the plot's statistics), then the
+ * `'point'` labels of all of them, and every style as svelteplot reads it ({@link MarkerStyles}).
  */
 export class MarkersPhase {
     phase = 'markers';
@@ -13,18 +14,23 @@ 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);
-                return { ...hooks, ...marker, styles: { ...styles, ...marker.styles } };
-            })
-            : [];
+        const rows = state.processedData?.data;
+        const positioned = MarkerChannels.inheritPosition(MarkerChannels.inheritAll([...options.marks(state, env), ...(state.markers ?? [])], state.scales), state.processedData);
+        // Point labels draw last, merged across markers so they declutter together.
+        const { markers, labels: pointLabels } = MarkerLabels.extractPoints(positioned, {
+            rows,
+            valueAxis: PlotAxes.valueOf(state),
+            isHorizontal: state.axes?.isHorizontal,
+            gap: env.cfg.text?.label.gap
+        });
         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([...markers, ...pointLabels], {
+                cfg: env.cfg,
+                rows
+            })
         };
     };
 }

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

@@ -1,33 +1,4 @@
-/** Marker kinds that split their rows into separate shapes per `grouping`. */
-const GROUPING_KINDS = new Set([
-    'area',
-    'density',
-    'line',
-    'hull',
-    'trail',
-    'delaunayLink',
-    'delaunayMesh',
-    'voronoi',
-    'voronoiMesh'
-]);
-/** Marker kinds whose per-row `color` resolves through the plot's own color scale. */
-const COLOR_KINDS = new Set([
-    'area',
-    'bar',
-    'cell',
-    'density',
-    'delaunayLink',
-    'delaunayMesh',
-    'dot',
-    'hull',
-    'line',
-    'rect',
-    'tick',
-    'trail',
-    'voronoi',
-    'voronoiMesh',
-    'waffle'
-]);
+import { MarkerKinds } from '../../markers/MarkerKinds';
 /** Kinds that draw only a line, so their flat color is `stroke` alone. */
 const LINE_KINDS = new Set(['line', 'regression', 'bollinger', 'delta']);
 /** Flat color style keys - when a marker sets one, it keeps that color instead of inheriting one. */
@@ -86,28 +57,14 @@ export class MarkerGrouping {
             if (grouping === undefined)
                 return MarkerGrouping.withSeriesColor(m, plot.defaultColor);
             const updates = {};
-            if (GROUPING_KINDS.has(m.type) && m.grouping === undefined)
+            if (MarkerKinds.inherits(m.type, 'grouping') && m.grouping === undefined)
                 updates.grouping = grouping;
-            if (COLOR_KINDS.has(m.type) && m.color === undefined && !MarkerGrouping.#hasFlatColor(m)) {
+            if (MarkerKinds.inherits(m.type, 'color') &&
+                m.color === undefined &&
+                !MarkerGrouping.#hasFlatColor(m)) {
                 updates.color = plot.color ?? plot.grouping;
             }
             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/statistics/MarkerInheritance.d.ts

@@ -0,0 +1,11 @@
+import type { InheritedChannel } from '../../types/markers/traits';
+/** How a plot's position and value channels reach the markers its author adds. */
+export declare class MarkerInheritance {
+    /**
+     * `marker` with the plot's `x`/`y` on each axis it sets no position for (`x`, `x1` or `x2`...), and the
+     * plot's other channels it sets none of, as far as its kind inherits them.
+     */
+    static inherit<T extends {
+        type: string;
+    }>(marker: T, plot: Partial<Record<InheritedChannel, unknown>>): T;
+}

package/dist/phases/statistics/MarkerInheritance.js

@@ -0,0 +1,25 @@
+import { MarkerKinds } from '../../markers/MarkerKinds';
+/** The value channels a marker takes as they are; `grouping` and `color` are `MarkerGrouping`'s. */
+const VALUES = ['opacity', 'symbol', 'r', 'length'];
+/** How a plot's position and value channels reach the markers its author adds. */
+export class MarkerInheritance {
+    /**
+     * `marker` with the plot's `x`/`y` on each axis it sets no position for (`x`, `x1` or `x2`...), and the
+     * plot's other channels it sets none of, as far as its kind inherits them.
+     */
+    static inherit(marker, plot) {
+        const own = marker;
+        const takes = (channel) => plot[channel] !== undefined && MarkerKinds.inherits(own.type, channel);
+        const taken = {};
+        for (const axis of ['x', 'y']) {
+            const unset = [axis, `${axis}1`, `${axis}2`].every((key) => own[key] === undefined);
+            if (unset && takes(axis))
+                taken[axis] = plot[axis];
+        }
+        for (const channel of VALUES) {
+            if (own[channel] === undefined && takes(channel))
+                taken[channel] = plot[channel];
+        }
+        return Object.keys(taken).length ? { ...own, ...taken } : marker;
+    }
+}

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

@@ -0,0 +1,26 @@
+type Marker = {
+    type: string;
+    isHorizontal?: boolean;
+    data?: unknown[];
+} & Record<string, unknown>;
+type AxisScales = {
+    x?: {
+        type?: string;
+    };
+    y?: {
+        type?: string;
+    };
+};
+/** Which way an oriented marker runs when its plot has no position channels to say it. */
+export declare class MarkerOrientation {
+    /** `marker` with `isHorizontal` taken from its own channels, unless it sets one or can't tell. */
+    static orient<T extends {
+        type: string;
+    }>(marker: T, rows: unknown[], scales?: AxisScales): T;
+    /**
+     * A band (`x1`/`x2` or `y1`/`y2`) runs across its own axis; two channels run as a plot's
+     * would; a single channel is the measured value.
+     */
+    static of(marker: Marker, rows: unknown[], scales?: AxisScales): boolean | undefined;
+}
+export {};

package/dist/phases/statistics/MarkerOrientation.js

@@ -0,0 +1,29 @@
+import { MarkerKinds } from '../../markers/MarkerKinds';
+import { PlotAxes } from '../data/PlotAxes';
+/** Which way an oriented marker runs when its plot has no position channels to say it. */
+export class MarkerOrientation {
+    /** `marker` with `isHorizontal` taken from its own channels, unless it sets one or can't tell. */
+    static orient(marker, rows, scales) {
+        const own = marker;
+        if (own.isHorizontal !== undefined || !MarkerKinds.of(own.type)?.oriented)
+            return marker;
+        const isHorizontal = MarkerOrientation.of(own, rows, scales);
+        return isHorizontal === undefined ? marker : { ...own, isHorizontal };
+    }
+    /**
+     * A band (`x1`/`x2` or `y1`/`y2`) runs across its own axis; two channels run as a plot's
+     * would; a single channel is the measured value.
+     */
+    static of(marker, rows, scales) {
+        const set = (...keys) => keys.some((key) => marker[key] !== undefined);
+        const [xBand, yBand] = [set('x1', 'x2'), set('y1', 'y2')];
+        if (xBand !== yBand)
+            return xBand;
+        const [x, y] = [set('x'), set('y')];
+        if (x && y) {
+            const data = marker.data ?? rows;
+            return PlotAxes.build({ series: [{ x: marker.x, y: marker.y, data }], scales }).isHorizontal;
+        }
+        return x !== y ? x : undefined;
+    }
+}

package/dist/phases/statistics/StatisticsPhase.js

@@ -1,9 +1,9 @@
 import { AuthorMarkers } from './AuthorMarkers';
 import { Statistics } from './Statistics';
+import { MarkerInheritance } from './MarkerInheritance';
+import { MarkerOrientation } from './MarkerOrientation';
 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']);
 /**
  * The "statistics" phase every axis-based plot shares: seeds `state.markers`
  * with the plot-level `statistics` resolved against every series, followed by
@@ -38,23 +38,23 @@ export class StatisticsPhase {
     #resolve(state) {
         const options = this.#options;
         const { resolvedSeries = [], flat = [], colorForSeries, statistics, authorMarkers = [] } = state;
-        const { inheritGrouping = true, inheritPositions = false } = options;
+        const { inheritGrouping = true } = options;
         const defaultColor = options.defaultColor
             ? options.defaultColor(state)
             : resolvedSeries[0] && colorForSeries?.(resolvedSeries[0].name);
         const onProcessed = authorMarkers.map((marker) => AuthorMarkers.withProcessedRows(marker, state.processedData));
-        const positioned = inheritPositions
-            ? onProcessed.map((marker) => {
-                if (!POSITIONED_KINDS.has(marker.type))
-                    return marker;
-                const own = marker;
-                return {
-                    ...own,
-                    x: own.x ?? resolvedSeries[0]?.x ?? state.x,
-                    y: own.y ?? resolvedSeries[0]?.y ?? state.y
-                };
-            })
-            : onProcessed;
+        const unpositioned = !state.axes?.x && !state.axes?.y;
+        const positioned = onProcessed.map((marker) => {
+            const inherited = MarkerInheritance.inherit(marker, {
+                x: resolvedSeries[0]?.x ?? state.x,
+                y: resolvedSeries[0]?.y ?? state.y,
+                opacity: state.opacity,
+                symbol: state.symbol,
+                r: state.r,
+                length: state.length
+            });
+            return unpositioned ? MarkerOrientation.orient(inherited, flat, state.scales) : inherited;
+        });
         // 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)

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)
     });
 }

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

@@ -1,15 +1,15 @@
-import type { AxisPlotCtx, AxisPlotState, PhaseStage } from '../../types/phases';
+import type { AxisPlotEnv, 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} -
  * 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). The value reads as the tooltip's
+ * the value each row's context gives it (a stacked row's own, not its running total). The value reads as the tooltip's
  * `decimals`, `prefix`, `suffix` and `signDisplay` ask. It
  * runs after the scales, which say which axis holds categories.
  */
-export declare class TooltipPhase<TState extends AnyAxisState> implements PhaseStage<TState, AxisPlotCtx> {
+export declare class TooltipPhase<TState extends AnyAxisState> implements PhaseStage<TState, AxisPlotEnv> {
     readonly phase: "tooltip";
-    run: (state: TState, ctx: AxisPlotCtx) => TState;
+    run: (state: TState, env: AxisPlotEnv) => TState;
 }
 export {};

package/dist/phases/tooltip/TooltipPhase.js

@@ -1,19 +1,22 @@
 import { TooltipState } from '../../layout/tooltip/TooltipState.svelte';
-import { ValueLabels } from '../../layout/styles/ValueLabels';
+import { RowContext } from '../context/RowContext';
 import { NumberFormat } from '../../utils/NumberFormat';
 /**
  * The "tooltip" phase every axis-based plot shares: how a hovered row reads,
  * 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). The value reads as the tooltip's
+ * the value each row's context gives it (a stacked row's own, not its running total). The value reads as the tooltip's
  * `decimals`, `prefix`, `suffix` and `signDisplay` ask. It
  * runs after the scales, which say which axis holds categories.
  */
 export class TooltipPhase {
     phase = 'tooltip';
-    run = (state, ctx) => ({
-        ...state,
-        tooltipFormat: TooltipState.default(state, NumberFormat.maybe(NumberFormat.displayOf(state.tooltip), ctx.cfg)),
-        tooltipSort: TooltipState.descending(ValueLabels.valueOf(state))
-    });
+    run = (state, env) => {
+        const contextOf = RowContext.reader(state);
+        return {
+            ...state,
+            tooltipFormat: TooltipState.default(state, NumberFormat.maybe(NumberFormat.displayOf(state.tooltip), env.cfg)),
+            tooltipSort: TooltipState.descending((row) => contextOf(row).value)
+        };
+    };
 }

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

@@ -18,10 +18,10 @@ export declare const GAP_KIND = "__gapKind";
  * `styles.gaps` fills is read at its interpolated value, so it takes its place
  * in a stack the way a real value would, and keeps its gap kind.
  */
-export declare class TransformsPhase<TState extends TransformsStageState, TCtx = unknown> implements PhaseStage<TState, TCtx> {
+export declare class TransformsPhase<TState extends TransformsStageState, TEnv = unknown> implements PhaseStage<TState, TEnv> {
     #private;
     readonly phase: "transforms";
     /** `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;
+    constructor(options?: TransformsStageOptions<TState, TEnv>, connect?: boolean);
+    run: (state: TState, env: TEnv) => TState;
 }