@fundar/data-chart-telling 0.0.64 → 1.0.0

package/dist/markers/tick/TickMarker.svelte

@@ -0,0 +1,44 @@
+<script lang="ts">
+	import { TickX, TickY } from 'svelteplot';
+	import { usePlot } from '../../layout/plot/usePlot';
+	import { MarkerChannels } from '../utils/MarkerChannels';
+	import { getConfiguration } from '../../configuration/config.svelte';
+	import type { TickMarkerConfig } from '../../types/markers/common';
+
+	/** Renders one `'tick'` marker as `<TickX>` or `<TickY>`, picked from the way the plot runs (`usePlot().axes`). */
+	let { marker }: { marker: TickMarkerConfig } = $props();
+
+	const plot = usePlot();
+	const isHorizontal = $derived(plot.axes?.isHorizontal ?? false);
+
+	const cfg = $derived(getConfiguration());
+	const data = $derived(marker.data ?? []);
+	const channelStroke = $derived(MarkerChannels.buildFill(data, marker.color, marker.scales, cfg));
+	const stroke = $derived(channelStroke ?? marker.styles?.stroke ?? 'currentColor');
+</script>
+
+{#if isHorizontal}
+	<TickX
+		{data}
+		x={marker.x}
+		y={marker.y}
+		tickLength={marker.tickLength}
+		{stroke}
+		strokeWidth={marker.styles?.strokeWidth}
+		strokeOpacity={marker.styles?.strokeOpacity}
+		strokeDasharray={marker.styles?.strokeDasharray}
+		strokeLinecap={marker.styles?.strokeLinecap}
+	/>
+{:else}
+	<TickY
+		{data}
+		x={marker.x}
+		y={marker.y}
+		tickLength={marker.tickLength}
+		{stroke}
+		strokeWidth={marker.styles?.strokeWidth}
+		strokeOpacity={marker.styles?.strokeOpacity}
+		strokeDasharray={marker.styles?.strokeDasharray}
+		strokeLinecap={marker.styles?.strokeLinecap}
+	/>
+{/if}

package/dist/markers/tick/TickMarker.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { TickMarkerConfig } from '../../types/markers/common';
+type $$ComponentProps = {
+    marker: TickMarkerConfig;
+};
+declare const TickMarker: import("svelte").Component<$$ComponentProps, {}, "">;
+type TickMarker = ReturnType<typeof TickMarker>;
+export default TickMarker;

package/dist/markers/trail/TrailMarker.svelte

@@ -0,0 +1,27 @@
+<script lang="ts">
+	import { Trail } from 'svelteplot';
+	import { MarkerChannels } from '../utils/MarkerChannels';
+	import { getConfiguration } from '../../configuration/config.svelte';
+	import type { TrailMarkerConfig } from '../../types/markers/common';
+
+	/** Renders one `'trail'` marker as `<Trail>` - a ribbon whose width follows `r`. */
+	let { marker }: { marker: TrailMarkerConfig } = $props();
+
+	const cfg = $derived(getConfiguration());
+	const data = $derived(marker.data ?? []);
+	const channelFill = $derived(MarkerChannels.buildFill(data, marker.color, marker.scales, cfg));
+</script>
+
+<Trail
+	{data}
+	x={marker.x}
+	y={marker.y}
+	r={marker.r}
+	z={marker.grouping}
+	curve={marker.curve}
+	tension={marker.tension}
+	cap={marker.cap}
+	resolution={marker.resolution}
+	fill={channelFill ?? marker.styles?.fill ?? cfg.palette[0]}
+	fillOpacity={marker.styles?.fillOpacity}
+/>

package/dist/markers/trail/TrailMarker.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { TrailMarkerConfig } from '../../types/markers/common';
+type $$ComponentProps = {
+    marker: TrailMarkerConfig;
+};
+declare const TrailMarker: import("svelte").Component<$$ComponentProps, {}, "">;
+type TrailMarker = ReturnType<typeof TrailMarker>;
+export default TrailMarker;

package/dist/markers/utils/BandNudge.d.ts

@@ -0,0 +1,22 @@
+import type { BandSlice } from '../../types/layout/hover';
+type BandScale = {
+    type?: string;
+    fn?: unknown;
+} | undefined;
+/**
+ * How far a mark sits off the middle of its category band, in pixels, when it
+ * belongs to one `slice` of the band (a grouped bar's series). Vertical bars
+ * slice their band along `x`, horizontal ones along `y`, from the bottom; the
+ * band is read at its drawn width.
+ */
+export declare class BandNudge {
+    #private;
+    static of(scales: {
+        x?: BandScale;
+        y?: BandScale;
+    }, slice: BandSlice | undefined): {
+        dx: number;
+        dy: number;
+    };
+}
+export {};

package/dist/markers/utils/BandNudge.js

@@ -0,0 +1,23 @@
+/**
+ * How far a mark sits off the middle of its category band, in pixels, when it
+ * belongs to one `slice` of the band (a grouped bar's series). Vertical bars
+ * slice their band along `x`, horizontal ones along `y`, from the bottom; the
+ * band is read at its drawn width.
+ */
+export class BandNudge {
+    static of(scales, slice) {
+        if (!slice)
+            return { dx: 0, dy: 0 };
+        const across = (slice.start - slice.end) / 2;
+        const bandX = BandNudge.#width(scales.x);
+        return bandX > 0
+            ? { dx: across * bandX, dy: 0 }
+            : { dx: 0, dy: -across * BandNudge.#width(scales.y) };
+    }
+    /** A band scale's drawn band width; `0` for any other scale. */
+    static #width(scale) {
+        return scale?.type === 'band'
+            ? (scale.fn.bandwidth?.() ?? 0)
+            : 0;
+    }
+}

package/dist/markers/utils/MarkerChannels.d.ts

@@ -0,0 +1,49 @@
+import type { ChannelScalesConfig } from '../../types/layout/scales';
+import type { SymbolType } from '../../types/plots/constants';
+import type { PlotStylesConfig } from '../../types/configuration/styling';
+/** One resolved opacity bucket: every row in `data` renders at exactly `value`. */
+export type OpacityBucket<TData> = {
+    value: number;
+    data: TData[];
+};
+/**
+ * What a marker's own `color`, `symbol` and `opacity` channels resolve to,
+ * over its rows, shared by every marker kind that intersects `CommonMarkerConfig`.
+ */
+export declare class MarkerChannels {
+    /**
+     * Resolves a `CommonMarkerConfig` pair into a per-row fill accessor, or
+     * `undefined` when `color` is unset (caller falls back to its own flat
+     * fill/stroke). Shared by every marker kind that intersects `CommonMarkerConfig`.
+     * Safe as a live per-row function - svelteplot recognizes an already-resolved
+     * CSS color string as a literal and never re-scales it (unlike `opacity`/`r`).
+     * Continuous (numeric) or categorical (string) values both work, same as a
+     * plot's own `color` channel - the theme's own 2-color ramp defaults a
+     * continuous value, its discrete `palette` a categorical one.
+     */
+    static buildFill<TData>(data: TData[], color: string | ((d: TData) => unknown) | undefined, scales: ChannelScalesConfig | undefined, cfg: PlotStylesConfig): ((d: TData) => string) | undefined;
+    /**
+     * Resolves a `CommonMarkerConfig`-style `symbol` pair into a per-row shape
+     * accessor, or `undefined` when unset. Safe as a live per-row function for
+     * the same reason `buildFill` is - a resolved shape name is a
+     * recognized literal, not re-scaled.
+     */
+    static buildSymbol<TData>(data: TData[], symbol: string | ((d: TData) => unknown) | undefined, scales: ChannelScalesConfig | undefined, cfg: PlotStylesConfig): ((d: TData) => SymbolType) | undefined;
+    /**
+     * Resolves a `CommonMarkerConfig`-style `opacity` pair into a list of
+     * opacity buckets, or `undefined` when unset. Unlike `buildFill`,
+     * this can NOT hand back a live per-row function - svelteplot treats
+     * `fillOpacity`/`opacity` as bound to its own shared scale (there's no
+     * "this number is already resolved, don't touch it" escape hatch the way a
+     * recognized CSS color string gets), so any function handed a per-row
+     * accessor gets its domain silently re-derived and re-normalized by
+     * svelteplot itself (verified empirically, not assumed). Bucketing rows by
+     * a quantized opacity value and rendering one mark instance per bucket
+     * (each with `value` as a literal constant) is the only way to land an
+     * exact, independently-resolved value - same technique `fillOpacity`/gap
+     * dimming already use elsewhere in this codebase (e.g. `heatmap/markers.ts`).
+     * `steps` bounds how many buckets (mark instances) a continuous value can
+     * produce - a visually-smooth compromise, not true infinite precision.
+     */
+    static buildOpacityBuckets<TData>(data: TData[], opacity: string | ((d: TData) => unknown) | undefined, scales: ChannelScalesConfig | undefined, cfg: PlotStylesConfig, steps?: number): OpacityBucket<TData>[] | undefined;
+}

package/dist/markers/utils/MarkerChannels.js

@@ -0,0 +1,97 @@
+import { resolveColorScale } from '../../utils/color';
+import { resolveOpacityScale } from '../../utils/opacity';
+import { resolveSymbolScale } from '../../utils/symbol';
+/**
+ * What a marker's own `color`, `symbol` and `opacity` channels resolve to,
+ * over its rows, shared by every marker kind that intersects `CommonMarkerConfig`.
+ */
+export class MarkerChannels {
+    /**
+     * Resolves a `CommonMarkerConfig` pair into a per-row fill accessor, or
+     * `undefined` when `color` is unset (caller falls back to its own flat
+     * fill/stroke). Shared by every marker kind that intersects `CommonMarkerConfig`.
+     * Safe as a live per-row function - svelteplot recognizes an already-resolved
+     * CSS color string as a literal and never re-scales it (unlike `opacity`/`r`).
+     * Continuous (numeric) or categorical (string) values both work, same as a
+     * plot's own `color` channel - the theme's own 2-color ramp defaults a
+     * continuous value, its discrete `palette` a categorical one.
+     */
+    static buildFill(data, color, scales, cfg) {
+        if (!color || !data.length)
+            return undefined;
+        const colorFn = typeof color === 'function' ? color : (d) => d[color];
+        const rawVals = data
+            .map((d) => colorFn(d))
+            .filter((v) => v != null && !(typeof v === 'number' && !Number.isFinite(v)));
+        if (!rawVals.length)
+            return undefined;
+        const allNumeric = rawVals.every((v) => Number.isFinite(Number(v)));
+        const domain = allNumeric
+            ? [Math.min(...rawVals.map(Number)), Math.max(...rawVals.map(Number))]
+            : [...new Set(rawVals.map(String))];
+        const defaultScheme = allNumeric ? [cfg.continuous.min, cfg.continuous.max] : cfg.palette;
+        const colorScale = resolveColorScale(scales?.color, domain, defaultScheme);
+        return (d) => colorScale(colorFn(d));
+    }
+    /**
+     * Resolves a `CommonMarkerConfig`-style `symbol` pair into a per-row shape
+     * accessor, or `undefined` when unset. Safe as a live per-row function for
+     * the same reason `buildFill` is - a resolved shape name is a
+     * recognized literal, not re-scaled.
+     */
+    static buildSymbol(data, symbol, scales, cfg) {
+        if (!symbol)
+            return undefined;
+        const symbolFn = typeof symbol === 'function' ? symbol : (d) => d[symbol];
+        const domain = [
+            ...new Set(data
+                .map((d) => symbolFn(d))
+                .filter((v) => v != null)
+                .map(String))
+        ];
+        if (!domain.length)
+            return undefined;
+        const scale = resolveSymbolScale(scales?.symbol, domain, cfg.symbols);
+        return (d) => scale(symbolFn(d));
+    }
+    /**
+     * Resolves a `CommonMarkerConfig`-style `opacity` pair into a list of
+     * opacity buckets, or `undefined` when unset. Unlike `buildFill`,
+     * this can NOT hand back a live per-row function - svelteplot treats
+     * `fillOpacity`/`opacity` as bound to its own shared scale (there's no
+     * "this number is already resolved, don't touch it" escape hatch the way a
+     * recognized CSS color string gets), so any function handed a per-row
+     * accessor gets its domain silently re-derived and re-normalized by
+     * svelteplot itself (verified empirically, not assumed). Bucketing rows by
+     * a quantized opacity value and rendering one mark instance per bucket
+     * (each with `value` as a literal constant) is the only way to land an
+     * exact, independently-resolved value - same technique `fillOpacity`/gap
+     * dimming already use elsewhere in this codebase (e.g. `heatmap/markers.ts`).
+     * `steps` bounds how many buckets (mark instances) a continuous value can
+     * produce - a visually-smooth compromise, not true infinite precision.
+     */
+    static buildOpacityBuckets(data, opacity, scales, cfg, steps = 32) {
+        if (!opacity || !data.length)
+            return undefined;
+        const opacityFn = typeof opacity === 'function'
+            ? opacity
+            : (d) => d[opacity];
+        const rawVals = data.map((d) => opacityFn(d)).filter((v) => v != null);
+        if (!rawVals.length)
+            return undefined;
+        const allNumeric = rawVals.every((v) => Number.isFinite(Number(v)));
+        const domain = allNumeric
+            ? [Math.min(...rawVals.map(Number)), Math.max(...rawVals.map(Number))]
+            : [...new Set(rawVals.map(String))];
+        const scale = resolveOpacityScale(scales?.opacity, domain, cfg.continuous.opacityRange);
+        const buckets = new Map();
+        for (const d of data) {
+            const resolved = scale(opacityFn(d));
+            const quantized = Math.round(resolved * steps) / steps;
+            if (!buckets.has(quantized))
+                buckets.set(quantized, []);
+            buckets.get(quantized).push(d);
+        }
+        return [...buckets.entries()].map(([value, rows]) => ({ value, data: rows }));
+    }
+}

package/dist/markers/vector/VectorMarker.svelte

@@ -0,0 +1,29 @@
+<script lang="ts">
+	import { Vector } from 'svelteplot';
+	import type { GeoVectorMarkerConfig } from '../../types/markers/geo';
+
+	/**
+	 * Renders one `'vector'` marker - arrows/spikes at points. `'arrow'`/`'spike'`
+	 * draw an open (stroked) path - svelteplot itself resolves their default
+	 * color via `stroke`, not `fill` (only `'arrow-filled'` is a closed, filled
+	 * shape) - so the default color applies to whichever channel the active
+	 * shape actually draws with, matching svelteplot's own convention.
+	 */
+	let { marker }: { marker: GeoVectorMarkerConfig } = $props();
+
+	const shape = $derived(marker.shape ?? 'arrow-filled');
+	const isFilledShape = $derived(shape === 'arrow-filled');
+</script>
+
+<Vector
+	data={marker.data}
+	x={marker.x}
+	y={marker.y}
+	length={marker.length}
+	rotate={marker.rotate}
+	{shape}
+	anchor={marker.anchor}
+	fill={marker.styles?.fill ?? (isFilledShape ? 'currentColor' : undefined)}
+	stroke={marker.styles?.stroke ?? (isFilledShape ? undefined : 'currentColor')}
+	strokeWidth={marker.styles?.strokeWidth}
+/>

package/dist/markers/{VectorMarker.svelte.d.ts → vector/VectorMarker.svelte.d.ts}

@@ -1,4 +1,4 @@
-import type { GeoVectorMarkerConfig } from '../types/markers/geo';
+import type { GeoVectorMarkerConfig } from '../../types/markers/geo';
 type $$ComponentProps = {
     marker: GeoVectorMarkerConfig;
 };

package/dist/markers/voronoi/VoronoiMarker.svelte

@@ -0,0 +1,26 @@
+<script lang="ts">
+	import { Voronoi } from 'svelteplot';
+	import { MarkerChannels } from '../utils/MarkerChannels';
+	import { getConfiguration } from '../../configuration/config.svelte';
+	import type { VoronoiMarkerConfig } from '../../types/markers/common';
+
+	/** Renders one `'voronoi'` marker as `<Voronoi>` - one Voronoi cell per point. */
+	let { marker }: { marker: VoronoiMarkerConfig } = $props();
+
+	const cfg = $derived(getConfiguration());
+	const data = $derived(marker.data ?? []);
+	const channelColor = $derived(MarkerChannels.buildFill(data, marker.color, marker.scales, cfg));
+</script>
+
+<Voronoi
+	{data}
+	x={marker.x}
+	y={marker.y}
+	z={marker.grouping}
+	fill={marker.styles?.fill}
+	fillOpacity={marker.styles?.fillOpacity}
+	stroke={marker.styles?.stroke ?? channelColor}
+	strokeWidth={marker.styles?.strokeWidth}
+	strokeOpacity={marker.styles?.strokeOpacity}
+	strokeDasharray={marker.styles?.strokeDasharray}
+/>

package/dist/markers/voronoi/VoronoiMarker.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { VoronoiMarkerConfig } from '../../types/markers/common';
+type $$ComponentProps = {
+    marker: VoronoiMarkerConfig;
+};
+declare const VoronoiMarker: import("svelte").Component<$$ComponentProps, {}, "">;
+type VoronoiMarker = ReturnType<typeof VoronoiMarker>;
+export default VoronoiMarker;

package/dist/markers/voronoi/VoronoiMeshMarker.svelte

@@ -0,0 +1,26 @@
+<script lang="ts">
+	import { VoronoiMesh } from 'svelteplot';
+	import { MarkerChannels } from '../utils/MarkerChannels';
+	import { getConfiguration } from '../../configuration/config.svelte';
+	import type { VoronoiMeshMarkerConfig } from '../../types/markers/common';
+
+	/** Renders one `'voronoiMesh'` marker as `<VoronoiMesh>` - the Voronoi diagram as a single mesh. */
+	let { marker }: { marker: VoronoiMeshMarkerConfig } = $props();
+
+	const cfg = $derived(getConfiguration());
+	const data = $derived(marker.data ?? []);
+	const channelColor = $derived(MarkerChannels.buildFill(data, marker.color, marker.scales, cfg));
+</script>
+
+<VoronoiMesh
+	{data}
+	x={marker.x}
+	y={marker.y}
+	z={marker.grouping}
+	fill={marker.styles?.fill}
+	fillOpacity={marker.styles?.fillOpacity}
+	stroke={marker.styles?.stroke ?? channelColor}
+	strokeWidth={marker.styles?.strokeWidth}
+	strokeOpacity={marker.styles?.strokeOpacity}
+	strokeDasharray={marker.styles?.strokeDasharray}
+/>

package/dist/markers/voronoi/VoronoiMeshMarker.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { VoronoiMeshMarkerConfig } from '../../types/markers/common';
+type $$ComponentProps = {
+    marker: VoronoiMeshMarkerConfig;
+};
+declare const VoronoiMeshMarker: import("svelte").Component<$$ComponentProps, {}, "">;
+type VoronoiMeshMarker = ReturnType<typeof VoronoiMeshMarker>;
+export default VoronoiMeshMarker;

package/dist/markers/waffle/WaffleMarker.svelte

@@ -0,0 +1,56 @@
+<script lang="ts">
+	import { WaffleX, WaffleY } from 'svelteplot';
+	import { usePlot } from '../../layout/plot/usePlot';
+	import { MarkerChannels } from '../utils/MarkerChannels';
+	import { getConfiguration } from '../../configuration/config.svelte';
+	import type { WaffleMarkerConfig } from '../../types/markers/common';
+
+	/** Renders one `'waffle'` marker as `<WaffleX>` or `<WaffleY>`, picked from the way the plot runs (`usePlot().axes`). */
+	let { marker }: { marker: WaffleMarkerConfig } = $props();
+
+	const plot = usePlot();
+	const isHorizontal = $derived(plot.axes?.isHorizontal ?? false);
+
+	const cfg = $derived(getConfiguration());
+	const data = $derived(marker.data ?? []);
+	const channelFill = $derived(MarkerChannels.buildFill(data, marker.color, marker.scales, cfg));
+	const fill = $derived(channelFill ?? marker.styles?.fill ?? cfg.palette[0]);
+</script>
+
+{#if isHorizontal}
+	<WaffleX
+		{data}
+		x={marker.x}
+		x1={marker.x1}
+		x2={marker.x2}
+		y={marker.y}
+		unit={marker.unit}
+		multiple={marker.multiple}
+		gap={marker.gap}
+		round={marker.round}
+		borderRadius={marker.styles?.borderRadius}
+		{fill}
+		fillOpacity={marker.styles?.fillOpacity}
+		stroke={marker.styles?.stroke}
+		strokeWidth={marker.styles?.strokeWidth}
+		strokeOpacity={marker.styles?.strokeOpacity}
+	/>
+{:else}
+	<WaffleY
+		{data}
+		x={marker.x}
+		y={marker.y}
+		y1={marker.y1}
+		y2={marker.y2}
+		unit={marker.unit}
+		multiple={marker.multiple}
+		gap={marker.gap}
+		round={marker.round}
+		borderRadius={marker.styles?.borderRadius}
+		{fill}
+		fillOpacity={marker.styles?.fillOpacity}
+		stroke={marker.styles?.stroke}
+		strokeWidth={marker.styles?.strokeWidth}
+		strokeOpacity={marker.styles?.strokeOpacity}
+	/>
+{/if}

package/dist/markers/waffle/WaffleMarker.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { WaffleMarkerConfig } from '../../types/markers/common';
+type $$ComponentProps = {
+    marker: WaffleMarkerConfig;
+};
+declare const WaffleMarker: import("svelte").Component<$$ComponentProps, {}, "">;
+type WaffleMarker = ReturnType<typeof WaffleMarker>;
+export default WaffleMarker;

package/dist/phases/Pipeline.d.ts

@@ -0,0 +1,108 @@
+import type { AxisPlotState, AxisPlotCtx, AxisPlotKind, AxisPlotDefaults, DataRunState, HoverStageOptions, PhaseStage, PlotPhase } from '../types/phases';
+import type { PlotStylesConfig } from '../types/configuration/styling';
+import type { FacetConfig } from '../types/layout/facet';
+import type { LegendState } from '../layout/legend/LegendState.svelte';
+import type { HoverStrategy } from '../types/layout/hover';
+import type { Accessor } from '../types/plots/data/common';
+/** The core props an axis plot kind seeds its pipeline from. */
+export type AxisPipelineProps<TData extends Record<string, unknown>> = {
+    series?: unknown[];
+    data?: TData[];
+    x?: Accessor<TData, unknown>;
+    y?: Accessor<TData, unknown>;
+    grouping?: Accessor<TData, unknown>;
+    color?: Accessor<TData, unknown>;
+    opacity?: unknown;
+    r?: unknown;
+    symbol?: unknown;
+    segments?: unknown;
+    styles?: {
+        gaps?: unknown;
+        values?: unknown;
+    };
+    scales?: object;
+    width?: number;
+    height?: number;
+    margins?: unknown;
+    tooltip?: unknown;
+    markers?: unknown[];
+    statistics?: unknown[];
+    transforms?: unknown[];
+};
+/** What a {@link Pipeline} knows besides its stages: how a run starts and its plot's defaults. */
+export type PipelineOptions<TState> = {
+    /** The state a run starts from, given its input. Unset, the input is the state. */
+    seed?: (input: any, rows?: unknown[]) => TState;
+    /** The plot's hover strategy when neither its `tooltip` nor a hover marker sets one. */
+    hoverStrategy?: HoverStageOptions<unknown>['strategy'];
+    /** How its plot steps through a timeline, unless the author says otherwise. */
+    timeline?: AxisPlotDefaults<never, never>['timeline'];
+};
+/**
+ * A plot's pipeline: its stages, one per phase, in {@link Pipeline.ORDER},
+ * and what its plot needs before any of them run - its hover strategy and
+ * timeline defaults. Every core of the plot runs it ({@link run}); with a
+ * facet, the plot first runs its data phases once over every panel
+ * ({@link runData}), and each panel's core runs only the rest.
+ *
+ * Stages declared out of phase order still run in it - with a warning, once,
+ * since the declared order would otherwise read as the one that runs.
+ */
+export declare class Pipeline<TState, TCtx = unknown> {
+    #private;
+    /**
+     * The phases that work on the plot's rows - everything before its scales,
+     * plus the domains its slices share - in order. They run once over every
+     * facet panel; the rest depend on each panel's own box.
+     */
+    static readonly DATA_PHASES: readonly PlotPhase[];
+    /** Every {@link PlotPhase}, in the order they run: the data phases, then each panel's own. */
+    static readonly ORDER: readonly PlotPhase[];
+    readonly stages: readonly PhaseStage<TState, TCtx>[];
+    constructor(stages: PhaseStage<TState, TCtx>[], options?: PipelineOptions<TState>);
+    /**
+     * An axis-based plot kind's pipeline: the shared stages, each set up with
+     * the kind's own options - its marks and value labels among them - started
+     * from a core's props. Built once per kind object.
+     */
+    static ofAxisKind<TState extends AxisPlotState<any, any, any, any>, TCtx extends AxisPlotCtx>(kind: AxisPlotKind<TState, TCtx> & Pick<AxisPlotDefaults<any, any>, 'timeline'>): Pipeline<TState, TCtx>;
+    /** A plot's pipeline from what its kind gives: its axis-kind defaults, or a pipeline of its own. */
+    static of(defaults: AxisPlotDefaults<any, any> | Pipeline<any, any>): Pipeline<any, any>;
+    /** The stage of `phase`, if the pipeline has one. */
+    stage(phase: PlotPhase): PhaseStage<TState, TCtx> | undefined;
+    /**
+     * A core's run: every stage over the state its `input` (an axis core's
+     * props) seeds - or, given `panelState` (one facet panel's part of
+     * {@link runData}), only the stages after the data phases, over that state
+     * with the input's own props (its box, margins and scales) on top.
+     */
+    run: (input: unknown, ctx: TCtx, panelState?: object) => TState;
+    /** Whether the pipeline has data phases to run once over every facet panel ({@link runData}). */
+    get facets(): boolean;
+    /**
+     * The data phases over `rows`, seeded from a core's `props`, with the
+     * plot's `facet`: one run that every facet panel then reads its part of,
+     * including the domains its slices share (its "sharedScales" phase).
+     */
+    runData(props: object, rows: unknown[], facet: FacetConfig<never> | undefined, legendInteraction: LegendState | null, cfg: PlotStylesConfig): DataRunState;
+    /**
+     * The plot's hover strategy when neither its `tooltip` nor a hover marker
+     * sets one, given its props: the kind's own, or the one its axes ask for,
+     * read after the "data" phase tells them apart.
+     */
+    hoverStrategy(props: object, cfg?: PlotStylesConfig): HoverStrategy;
+    /** The plot's default `timeline.filterMode`. */
+    get filterMode(): 'exact' | 'upTo' | undefined;
+    /**
+     * How the plot tweens its timeline unless `timeline.interpolate` says
+     * otherwise, from the channels its "mapping" phase resolves over
+     * `props.data`: rows matched by the values of whichever `key` channels are
+     * set, `value` tweened. `undefined` when its kind tweens nothing.
+     */
+    interpolation<TRow extends Record<string, unknown>>(props: {
+        data?: TRow[];
+    }, cfg: PlotStylesConfig): {
+        value: Accessor<TRow, never>;
+        key?: Accessor<TRow, unknown>;
+    } | undefined;
+}