@fundar/data-chart-telling 1.17.0 → 1.19.0

package/dist/layout/geometry/ScaleFreeContext.js

@@ -0,0 +1,65 @@
+/**
+ * svelteplot's plot context as the marks drawn under a `ScaleFreeMarks` see it: the plot's own state and scales,
+ * but marks that never join the plot's list of marks.
+ *
+ * svelteplot works out a plot's scales from every mark it holds - their data and options - so a mark whose data
+ * changes at every move of the pointer (a hover's dot, its rule, its value) lays the whole plot out again each time:
+ * every scale built anew from every row, every mark scaled again, the margins measured again. A mark that is only
+ * drawn on the plot's scales, never shaping them, can be left out of them.
+ *
+ * Left out, a mark is in none of the scales' `skip` lists either - the marks whose channel values are already
+ * output (a color, a symbol, an opacity) and go through no scale. What these marks draw has no scale of its own to
+ * go through, so every such channel of theirs is taken as it is: a hover's colors are its points' own, resolved.
+ */
+/** The scales whose channel values a scale-free mark takes as they are, never through the scale. */
+const OUTPUT_SCALES = new Set(['color', 'opacity', 'symbol']);
+/** A `skip` list holding every mark: each of the channel's values is output already. */
+const EVERY_MARK = { has: () => true };
+const SKIP_ALL = { get: () => EVERY_MARK };
+/** A Proxy's `get` reading `target`'s own property (a class getter runs on the target, its private fields there). */
+const read = (target, key) => {
+    const value = Reflect.get(target, key);
+    return typeof value === 'function' ? value.bind(target) : value;
+};
+const scaleViews = new WeakMap();
+const scalesViews = new WeakMap();
+const stateViews = new WeakMap();
+/** One cached view of `target` per object, so a mark that derives from it sees the same one until it changes. */
+function viewOf(cache, target, make) {
+    let view = cache.get(target);
+    if (!view) {
+        view = make(target);
+        cache.set(target, view);
+    }
+    return view;
+}
+/** A scale whose `skip` holds every mark. */
+const outputScale = (scale) => viewOf(scaleViews, scale, (s) => new Proxy(s, { get: (t, k) => (k === 'skip' ? SKIP_ALL : read(t, k)) }));
+/** The plot's scales, its output scales skipping every mark. */
+const scalesView = (scales) => viewOf(scalesViews, scales, (s) => new Proxy(s, {
+    get: (t, k) => {
+        const scale = read(t, k);
+        return OUTPUT_SCALES.has(k) && scale && typeof scale === 'object'
+            ? outputScale(scale)
+            : scale;
+    }
+}));
+/** The plot's state, read live, with its scales as `scalesView` shows them. */
+const stateView = (state) => viewOf(stateViews, state, (s) => new Proxy(s, {
+    get: (t, k) => {
+        const value = read(t, k);
+        return k === 'scales' && value && typeof value === 'object' ? scalesView(value) : value;
+    }
+}));
+export const ScaleFreeContext = {
+    /** `parent`, the plot's own context, for marks drawn on its scales that never take part in them. */
+    of(parent) {
+        return {
+            ...parent,
+            addMark: () => { },
+            removeMark: () => { },
+            updateMark: () => { },
+            getPlotState: () => stateView(parent.getPlotState())
+        };
+    }
+};

package/dist/layout/geometry/ScaleFreeMarks.svelte

@@ -0,0 +1,14 @@
+<script lang="ts">
+	import { getContext, setContext, type Snippet } from 'svelte';
+	import { ScaleFreeContext, type SvelteplotContext } from './ScaleFreeContext';
+
+	/**
+	 * Draws its markers on the plot's scales without them taking part in the scales: what changes at every move of
+	 * the pointer - the hover's markers - never makes svelteplot work out the scales again. See `ScaleFreeContext`.
+	 */
+	let { children }: { children: Snippet } = $props();
+
+	setContext('svelteplot', ScaleFreeContext.of(getContext<SvelteplotContext>('svelteplot')));
+</script>
+
+{@render children()}

package/dist/layout/geometry/ScaleFreeMarks.svelte.d.ts

@@ -0,0 +1,7 @@
+import { type Snippet } from 'svelte';
+type $$ComponentProps = {
+    children: Snippet;
+};
+declare const ScaleFreeMarks: import("svelte").Component<$$ComponentProps, {}, "">;
+type ScaleFreeMarks = ReturnType<typeof ScaleFreeMarks>;
+export default ScaleFreeMarks;

package/dist/layout/geometry/ScaleGate.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { SvelteplotContext } from './ScaleFreeContext';
+export declare const ScaleGate: {
+    /**
+     * `parent`, the plot's own context, with each mark handed to the plot behind a `GatedMark`: the scales are
+     * worked out again when a mark's rows hold something new, not each time the mark copies them.
+     */
+    of(parent: SvelteplotContext): SvelteplotContext;
+};

package/dist/layout/geometry/ScaleGate.svelte.js

@@ -0,0 +1,95 @@
+import { RowContext } from '../../phases/context/RowContext';
+/**
+ * A mark as its plot sees it: the mark itself, but for its rows, which change only when they hold something new.
+ *
+ * svelteplot works a plot's scales out from every mark's rows, again whenever one of them is a new array. A mark
+ * hands it a new array each time it copies its rows (any of its props a new value is enough) and the next time
+ * one row's style changes, even a style that no scale reads - a hover's, at every move of the pointer. The copy
+ * holds the same rows, so the scales would come out the same: the plot is told of it only when a row differs.
+ */
+class GatedMark {
+    #mark;
+    /** The rows the plot last saw, kept while the mark's are a copy of them. */
+    data = $derived.by(() => this.#rows(this.#mark.data));
+    #seen;
+    constructor(mark) {
+        this.#mark = mark;
+    }
+    get id() {
+        return this.#mark.id;
+    }
+    get type() {
+        return this.#mark.type;
+    }
+    get channels() {
+        return this.#mark.channels;
+    }
+    get scales() {
+        return this.#mark.scales;
+    }
+    get options() {
+        return this.#mark.options;
+    }
+    #rows(rows) {
+        const seen = this.#seen;
+        if (seen && GatedMark.#sameRows(seen, rows))
+            return seen;
+        this.#seen = rows;
+        return rows;
+    }
+    /** Whether two lists of rows hold the same values, row by row and field by field. */
+    static #sameRows(a, b) {
+        if (a === b)
+            return true;
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!GatedMark.#sameRow(a[i], b[i]))
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Whether two rows hold the same values, field by field - but for the context the plot keeps on each row, which
+     * no scale reads and which the plot works out anew as it lays its rows out again.
+     */
+    static #sameRow(a, b) {
+        if (a === b)
+            return true;
+        if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+            return false;
+        const keys = Reflect.ownKeys(a);
+        if (keys.length !== Reflect.ownKeys(b).length)
+            return false;
+        return keys.every((key) => key === RowContext.key ||
+            Object.is(a[key], b[key]));
+    }
+}
+export const ScaleGate = {
+    /**
+     * `parent`, the plot's own context, with each mark handed to the plot behind a `GatedMark`: the scales are
+     * worked out again when a mark's rows hold something new, not each time the mark copies them.
+     */
+    of(parent) {
+        // Which gate stands for which mark: bookkeeping no view reads, so nothing has to react to it.
+        // eslint-disable-next-line svelte/prefer-svelte-reactivity
+        const gates = new Map();
+        return {
+            ...parent,
+            addMark: (mark) => {
+                if (gates.has(mark.id))
+                    return;
+                const gate = new GatedMark(mark);
+                gates.set(mark.id, gate);
+                parent.addMark(gate);
+            },
+            removeMark: (mark) => {
+                const gate = gates.get(mark.id);
+                if (!gate)
+                    return;
+                gates.delete(mark.id);
+                parent.removeMark(gate);
+            }
+        };
+    }
+};

package/dist/layout/geometry/ScaleGateMarks.svelte

@@ -0,0 +1,15 @@
+<script lang="ts">
+	import { getContext, setContext, type Snippet } from 'svelte';
+	import { ScaleGate } from './ScaleGate.svelte';
+	import type { SvelteplotContext } from './ScaleFreeContext';
+
+	/**
+	 * Hands every mark drawn under it to svelteplot's plot behind a gate: the plot works its scales out again when a
+	 * mark's rows hold something new, not each time the mark copies them. See `ScaleGate`.
+	 */
+	let { children }: { children: Snippet } = $props();
+
+	setContext('svelteplot', ScaleGate.of(getContext<SvelteplotContext>('svelteplot')));
+</script>
+
+{@render children()}

package/dist/layout/geometry/ScaleGateMarks.svelte.d.ts

@@ -0,0 +1,7 @@
+import { type Snippet } from 'svelte';
+type $$ComponentProps = {
+    children: Snippet;
+};
+declare const ScaleGateMarks: import("svelte").Component<$$ComponentProps, {}, "">;
+type ScaleGateMarks = ReturnType<typeof ScaleGateMarks>;
+export default ScaleGateMarks;

package/dist/layout/hover/HoverDefaults.d.ts

@@ -0,0 +1,52 @@
+import type { HoverDisplayPoint, HoverStrategy } from '../../types/layout/hover';
+import type { HoverLayerMarker, HoverLook, HoverMarkerConfig } from '../../types/markers/common';
+import type { PlotStylesConfig } from '../../types/configuration/styling';
+/** An end of a span: a field of the hovered point's context (else of its row), or a function of the point. */
+type SpanEnd = string | ((point: HoverDisplayPoint) => unknown);
+/**
+ * The hover a plot kind draws, and how an author's `hover` marker is laid over it. Its parts - a crosshair rule, a
+ * band, a dot, a label - are the markers a kind composes its own hover from; each takes the configuration's
+ * `hover` look as it is drawn (see `HoverLayers`).
+ */
+export declare class HoverDefaults {
+    /** A crosshair along `axis`, at the point under the pointer. */
+    static rule(axis: 'x' | 'y'): HoverLayerMarker;
+    /** The band of each hovered category along `axis`, or its series' slice of it when it alone is hovered there. */
+    static band(axis: 'x' | 'y'): HoverLayerMarker;
+    /**
+     * The span of the point under the pointer along `axis`, from `from` to `to`, across the whole of the other axis -
+     * where a band is no category's: a histogram's bin, an interval on a continuous axis. Each end is a field of the
+     * point's context (a bin's `from` and `to`) - else of its row - or a function of the point.
+     */
+    static span(axis: 'x' | 'y', from: SpanEnd, to: SpanEnd): HoverLayerMarker;
+    /** A dot on each hovered point, in its series' color. */
+    static dot(): HoverLayerMarker;
+    /** Each hovered point's label, in its series' color. */
+    static text(): HoverLayerMarker;
+    /**
+     * A hover that only restyles the shapes, with `active` and `others`: a treemap's tiles, a heatmap's cells. The
+     * hovered one is outlined, in the configuration's `hover.active`.
+     */
+    static shapes(cfg: PlotStylesConfig): HoverLook;
+    /** The hovered category's band along `axis`, behind the plot's shapes: a bar's, a box's, a violin's. */
+    static behindBand(axis: 'x' | 'y'): HoverLook;
+    /** The span of the point under the pointer along `axis`, behind the plot's shapes: a histogram's bin. */
+    static behindSpan(axis: 'x' | 'y', from: SpanEnd, to: SpanEnd): HoverLook;
+    /**
+     * A rule along the value axis at the point under the pointer, and a dot and a label on each point - for a plot
+     * whose other axis holds a few positions or categories, where a crosshair along it says little (a slope's, a
+     * Cleveland plot's).
+     */
+    static valueRule(valueAxis: 'x' | 'y'): HoverLook;
+    /**
+     * The hover every plot kind starts from: a crosshair along each axis its `strategy` matches along (unless
+     * `crosshair` is off), and a dot and a label on each hovered point.
+     */
+    static of(strategy: HoverStrategy, crosshair?: boolean | undefined): HoverLook;
+    /**
+     * An author's `hover` marker over its kind's `look`: `active` and `others` field by field, `back` and `front`
+     * the author's when set (an empty list draws nothing), the kind's otherwise.
+     */
+    static merge(look: HoverLook, marker: HoverMarkerConfig): HoverMarkerConfig;
+}
+export {};

package/dist/layout/hover/HoverDefaults.js

@@ -0,0 +1,96 @@
+/**
+ * The hover a plot kind draws, and how an author's `hover` marker is laid over it. Its parts - a crosshair rule, a
+ * band, a dot, a label - are the markers a kind composes its own hover from; each takes the configuration's
+ * `hover` look as it is drawn (see `HoverLayers`).
+ */
+export class HoverDefaults {
+    /** A crosshair along `axis`, at the point under the pointer. */
+    static rule(axis) {
+        return { type: 'rule', axis, points: 'active' };
+    }
+    /** The band of each hovered category along `axis`, or its series' slice of it when it alone is hovered there. */
+    static band(axis) {
+        return { type: 'band', axis };
+    }
+    /**
+     * The span of the point under the pointer along `axis`, from `from` to `to`, across the whole of the other axis -
+     * where a band is no category's: a histogram's bin, an interval on a continuous axis. Each end is a field of the
+     * point's context (a bin's `from` and `to`) - else of its row - or a function of the point.
+     */
+    static span(axis, from, to) {
+        const end = (side) => typeof side === 'function'
+            ? side
+            : (point) => point.context?.[side] ?? point.row?.[side];
+        return {
+            type: 'rect',
+            [`${axis}1`]: end(from),
+            [`${axis}2`]: end(to),
+            points: 'active'
+        };
+    }
+    /** A dot on each hovered point, in its series' color. */
+    static dot() {
+        return { type: 'dot' };
+    }
+    /** Each hovered point's label, in its series' color. */
+    static text() {
+        return { type: 'text' };
+    }
+    /**
+     * A hover that only restyles the shapes, with `active` and `others`: a treemap's tiles, a heatmap's cells. The
+     * hovered one is outlined, in the configuration's `hover.active`.
+     */
+    static shapes(cfg) {
+        return { back: [], front: [], active: { ...cfg.hover.active } };
+    }
+    /** The hovered category's band along `axis`, behind the plot's shapes: a bar's, a box's, a violin's. */
+    static behindBand(axis) {
+        return { back: [HoverDefaults.band(axis)], front: [] };
+    }
+    /** The span of the point under the pointer along `axis`, behind the plot's shapes: a histogram's bin. */
+    static behindSpan(axis, from, to) {
+        return { back: [HoverDefaults.span(axis, from, to)], front: [] };
+    }
+    /**
+     * A rule along the value axis at the point under the pointer, and a dot and a label on each point - for a plot
+     * whose other axis holds a few positions or categories, where a crosshair along it says little (a slope's, a
+     * Cleveland plot's).
+     */
+    static valueRule(valueAxis) {
+        return {
+            back: [HoverDefaults.rule(valueAxis)],
+            front: [HoverDefaults.dot(), HoverDefaults.text()]
+        };
+    }
+    /**
+     * The hover every plot kind starts from: a crosshair along each axis its `strategy` matches along (unless
+     * `crosshair` is off), and a dot and a label on each hovered point.
+     */
+    static of(strategy, crosshair = true) {
+        const axes = strategy === 'x'
+            ? ['x']
+            : strategy === 'y'
+                ? ['y']
+                : strategy === 'punctual'
+                    ? ['x', 'y']
+                    : [];
+        return {
+            back: crosshair === false ? [] : axes.map((axis) => HoverDefaults.rule(axis)),
+            front: [HoverDefaults.dot(), HoverDefaults.text()]
+        };
+    }
+    /**
+     * An author's `hover` marker over its kind's `look`: `active` and `others` field by field, `back` and `front`
+     * the author's when set (an empty list draws nothing), the kind's otherwise.
+     */
+    static merge(look, marker) {
+        const styles = (own, base) => own || base ? { ...base, ...own } : undefined;
+        return {
+            ...marker,
+            active: styles(marker.active, look.active),
+            others: styles(marker.others, look.others),
+            back: marker.back ?? look.back ?? [],
+            front: marker.front ?? look.front ?? []
+        };
+    }
+}

package/dist/layout/hover/HoverLayers.d.ts

@@ -0,0 +1,35 @@
+import type { BandSlice, HoverDisplayPoint } from '../../types/layout/hover';
+import type { HoverLayerMarker, HoverMarkerConfig } from '../../types/markers/common';
+import type { PlotStylesConfig } from '../../types/configuration/styling';
+type Point = HoverDisplayPoint & {
+    row?: unknown;
+};
+/** One marker a hover layer draws, keyed so it keeps its place while the hover moves, and the slice it is moved into. */
+export type HoverLayerPart = {
+    key: string;
+    marker: HoverLayerMarker;
+    slice?: BandSlice;
+};
+/** Some hovered points: of the whole plot, of one series, or of one segment of it, with the one under the pointer. */
+export type HoverPointGroup = {
+    key: string;
+    points: Point[];
+    active: Point | null;
+};
+/**
+ * The markers a `hover` marker draws in its `back` and `front` layers, over the hovered points: each with the
+ * points as its rows, unless it has `data` of its own, placed at them, and split by the slice of the band a point
+ * sits in (a grouped bar's series), to be moved into it - all but a `band`, which takes the slice itself.
+ */
+export declare class HoverLayers {
+    #private;
+    /** `points` with their label written as `marker`'s number fields, or its `format`, ask. */
+    static labelled<T extends Point>(points: readonly T[], marker: HoverMarkerConfig, cfg: PlotStylesConfig): T[];
+    /**
+     * The markers of `marker`'s `layer` over a group of points. A marker over points that sit in a slice of their
+     * band is one part per slice, which `slice` names, to be moved into it as it is drawn - the move is in pixels,
+     * so it is left to the drawing, which knows the band's width.
+     */
+    static parts(marker: HoverMarkerConfig, layer: 'back' | 'front', group: HoverPointGroup, cfg: PlotStylesConfig): HoverLayerPart[];
+}
+export {};

package/dist/layout/hover/HoverLayers.js

@@ -0,0 +1,122 @@
+import { NumberFormat } from '../../utils/NumberFormat';
+/**
+ * The markers a `hover` marker draws in its `back` and `front` layers, over the hovered points: each with the
+ * points as its rows, unless it has `data` of its own, placed at them, and split by the slice of the band a point
+ * sits in (a grouped bar's series), to be moved into it - all but a `band`, which takes the slice itself.
+ */
+export class HoverLayers {
+    /** The kinds placed by `x` and `y`, which default to the point's. */
+    static #PLACED = new Set(['dot', 'text', 'tick', 'image', 'line', 'trail']);
+    /** `points` with their label written as `marker`'s number fields, or its `format`, ask. */
+    static labelled(points, marker, cfg) {
+        const numberOf = NumberFormat.maybe(NumberFormat.displayOf(marker), cfg);
+        const number = numberOf ?? NumberFormat.of(undefined, cfg);
+        const { format } = marker;
+        if (!format && !numberOf)
+            return [...points];
+        return points.map((point) => {
+            if (format)
+                return { ...point, label: format(point, number) };
+            const value = Number(point.label);
+            const written = point.label !== undefined && point.label !== '' && Number.isFinite(value)
+                ? numberOf(value)
+                : point.label;
+            return { ...point, label: written ?? '' };
+        });
+    }
+    /**
+     * The markers of `marker`'s `layer` over a group of points. A marker over points that sit in a slice of their
+     * band is one part per slice, which `slice` names, to be moved into it as it is drawn - the move is in pixels,
+     * so it is left to the drawing, which knows the band's width.
+     */
+    static parts(marker, layer, group, cfg) {
+        if (group.points.length === 0)
+            return [];
+        return (marker[layer] ?? []).flatMap((nested, i) => {
+            const key = `${layer}-${group.key}-${i}`;
+            const { points: which, ...own } = nested;
+            if (own.data)
+                return [{ key, marker: own }];
+            const rows = HoverLayers.#pointsOf(which, group);
+            if (rows.length === 0)
+                return [];
+            const placed = HoverLayers.#placed(HoverLayers.#inHover(own, cfg));
+            if (own.type === 'band')
+                return [{ key, marker: { ...placed, data: rows } }];
+            return HoverLayers.#bySlice(rows).map(({ slice, points }) => ({
+                key: `${key}-${slice ? `${slice.start},${slice.end}` : ''}`,
+                marker: { ...placed, data: points },
+                slice
+            }));
+        });
+    }
+    /** The points a nested marker draws: all of them, the one under the pointer, or those a function keeps. */
+    static #pointsOf(which, group) {
+        if (which === 'active')
+            return group.active ? [group.active] : [];
+        if (typeof which === 'function')
+            return group.points.filter(which);
+        return group.points;
+    }
+    /**
+     * `marker` with what it leaves unset taken from the hover: a `rule` at each point along its axis and a `band`
+     * around it, in its slice; a `text` writes the point's label; each in the configuration's `hover` look (a `rect`
+     * too, in its `area` one), and a `dot` and a `text` in the point's series color.
+     */
+    static #inHover(marker, cfg) {
+        const own = marker;
+        const color = (point) => point.color ?? 'currentColor';
+        switch (marker.type) {
+            case 'rule':
+                return {
+                    ...marker,
+                    value: own.value ?? ((point) => point[marker.axis]),
+                    styles: { ...cfg.hover.rule, ...own.styles }
+                };
+            case 'band':
+                return {
+                    ...marker,
+                    value: own.value ?? ((point) => point[marker.axis]),
+                    slice: own.slice ?? ((point) => point.areaInset),
+                    styles: { ...cfg.hover.area, ...own.styles }
+                };
+            case 'rect':
+                return { ...marker, styles: { ...cfg.hover.area, ...own.styles } };
+            case 'dot':
+                return {
+                    ...marker,
+                    styles: { ...cfg.hover.dot, dotFill: color, dotStroke: color, ...own.styles }
+                };
+            case 'text':
+                return {
+                    ...marker,
+                    text: own.text ?? ((point) => point.label),
+                    styles: { ...cfg.hover.font, fill: color, ...own.styles }
+                };
+            default:
+                return marker;
+        }
+    }
+    /** `marker` placed at the points: its own `x` and `y`, else the point's. */
+    static #placed(marker) {
+        if (!HoverLayers.#PLACED.has(marker.type))
+            return marker;
+        const own = marker;
+        return {
+            ...marker,
+            x: own.x ?? ((point) => point.x),
+            y: own.y ?? ((point) => point.y)
+        };
+    }
+    /** `points` split by the slice of the band each one sits in, in the order they come. */
+    static #bySlice(points) {
+        const groups = new Map();
+        for (const point of points) {
+            const slice = point.areaInset;
+            const id = slice ? `${slice.start},${slice.end}` : '';
+            const group = groups.get(id) ?? groups.set(id, { slice, points: [] }).get(id);
+            group.points.push(point);
+        }
+        return [...groups.values()];
+    }
+}

package/dist/layout/hover/HoverSettings.d.ts

@@ -1,4 +1,4 @@
-import type { TooltipContext, TooltipProp } from '../../types/layout/tooltip';
+import type { TooltipProp } from '../../types/layout/tooltip';
 import type { HoverPoint, HoverStrategy } from '../../types/layout/hover';
 import { PlotAxes } from '../../phases/data/PlotAxes';
 import type { HoverConfig, PointMatchingStrategy, TooltipConfig } from '../../types/plots/props';
@@ -31,7 +31,5 @@ export declare class HoverSettings<TRow extends Record<string, unknown>> {
         defaultStrategy: HoverStrategy;
         pointMatching?: PointMatchingStrategy;
         number?: (value: number) => string;
-        /** What the plot knows of a row, the third argument of the author's own `format` - see {@link TooltipContext}. */
-        context?: (row: TRow) => TooltipContext;
     }): HoverConfig<TRow>;
 }

package/dist/layout/hover/HoverSettings.js

@@ -1,3 +1,4 @@
+import { RowContext } from '../../phases/context/RowContext';
 import { PlotAxes } from '../../phases/data/PlotAxes';
 /**
  * A plot's hover as its `tooltip` and hover marker set it up: whether it is on,
@@ -33,7 +34,7 @@ export class HoverSettings {
     }
     /** A plot's `hover` config; its tooltip reads as `format` unless it sets its own. */
     static buildConfig(args) {
-        const { tooltip, format, sort, markers, points, label, defaultStrategy, pointMatching, context } = args;
+        const { tooltip, format, sort, markers, points, label, defaultStrategy, pointMatching } = args;
         const number = args.number ?? String;
         const settings = new HoverSettings(tooltip, markers, defaultStrategy);
         return {
@@ -45,7 +46,7 @@ export class HoverSettings {
             tooltip: tooltip && {
                 ...tooltip,
                 format: tooltip.format
-                    ? (row) => tooltip.format(row, number, context?.(row) ?? {})
+                    ? (row) => tooltip.format(row, number, RowContext.of(row))
                     : format,
                 ...(sort ? { sort } : {})
             },

package/dist/layout/hover/HoverShapes.d.ts

@@ -0,0 +1,56 @@
+import type { HoverShapeStyle } from '../../types/markers/common';
+import type { PlotStylesConfig } from '../../types/configuration/styling';
+type Row = Record<string, unknown>;
+type Role = 'active' | 'other';
+/** What a hover marker sets for the shapes linked to the hover. */
+type ShapeRule = {
+    active?: HoverShapeStyle;
+    others?: HoverShapeStyle;
+    series?: string;
+};
+/** What the plot tells about each row the shapes draw. */
+export type HoverShapesReach = {
+    /** How the hover reaches a row - see `PlotHover.roleOf`. */
+    roleOf: (row: Row, series?: string) => Role | null;
+    /** Whether the legend dims the row's series, which then keeps its own fill and opacities. */
+    dimmed: (row: Row) => boolean;
+    cfg: PlotStylesConfig;
+};
+/**
+ * The look the plot's hover markers give the shapes of every marker linked to the hover (`hover: true` or
+ * `'style'`): the hovered ones take `active`, the others `others`, each over the shape's own style. A shape
+ * the legend dims keeps its own fill and opacities; one the hover cannot reach (hidden, omitted) is untouched.
+ *
+ * The marker stays one marker over all its rows, whatever is hovered: each style the hover sets is a function of
+ * the row that asks the hover how it reaches it. Moving the pointer then only draws the marker's shapes again in
+ * their new look - their rows and options do not change, so svelteplot never works the plot's scales out again
+ * (it does so from every mark's data and options, and a style with no scale is never read for them).
+ */
+export declare class HoverShapes {
+    #private;
+    constructor(markers: readonly ({
+        type: string;
+    } & ShapeRule)[]);
+    /** Whether any hover marker restyles shapes. */
+    get any(): boolean;
+    /** Whether `marker`'s shapes take the hover's styles. */
+    static links(marker: object): boolean;
+    /**
+     * `marker` with each style the hover sets as a function of the row: the hovered rows take `active`, the others
+     * `others`, and while nothing is hovered every row its own style. A marker the hover does not style is returned
+     * as it is. `rows` are what the marker draws without `data` of its own.
+     *
+     * The outline `active` sets is not the shape's own: {@link outline} draws it over every shape, whole.
+     */
+    styled<T extends object>(marker: T, rows: readonly unknown[], reach: HoverShapesReach): T;
+    /** Whether any rule outlines the hovered shapes: an `active` that sets one of the stroke's fields. */
+    get outlines(): boolean;
+    /**
+     * The outline of `marker`'s hovered shapes, to draw over every shape of the plot: the marker over its hovered
+     * rows only, with no fill, no label and no pointer of its own. A shape is drawn in its marker's order, so its
+     * neighbours drawn after it would cover part of its outline - a treemap's tile, a heatmap's cell with no gap.
+     * `undefined` when no rule outlines the shapes or nothing of the marker is hovered.
+     */
+    outline<T extends object>(marker: T, rows: readonly unknown[], reach: HoverShapesReach): T | undefined;
+}
+export {};