@fundar/data-chart-telling 1.17.0 → 1.19.0

package/dist/types/markers/basic/dot.d.ts

@@ -1,3 +1,6 @@
+import type { RimLabelConfig } from '../labels/path';
+import type { PointLabelConfig } from '../labels/point';
+import type { CommonMarkerConfigWithLabel } from '../channels/commonMarkerConfigWithLabel';
 import type { DotStyle, PerRow } from '../../plots/styling';
 import type { CommonMarkerConfigWithColor } from '../channels/commonMarkerConfigWithColor';
 import type { CommonMarkerConfigWithRadius } from '../channels/commonMarkerConfigWithRadius';
@@ -7,4 +10,4 @@ import type { CommonMarkerConfigWithSymbol } from '../channels/commonMarkerConfi
 export type DotMarkerConfig = CommonMarkerConfigWithRowOffset<{
     type: 'dot';
     styles?: PerRow<DotStyle>;
-} & CommonMarkerConfigWithRadius & CommonMarkerConfigWithColor & CommonMarkerConfigWithSymbol>;
+} & CommonMarkerConfigWithRadius & CommonMarkerConfigWithColor & CommonMarkerConfigWithSymbol & CommonMarkerConfigWithLabel<RimLabelConfig | PointLabelConfig>>;

package/dist/types/markers/basic/text.d.ts

@@ -1,16 +1,23 @@
+import type { CoveringShape } from '../labels/point';
 import type { FontStyle, StrokeStyle, PerRow } from '../../plots/styling';
 import type { CommonMarkerConfig } from '../channels/commonMarkerConfig';
 import type { CommonMarkerConfigWithRowOffset } from '../channels/commonMarkerConfigWithRowOffset';
 import type { Margins } from '../../../layout/margins/Margins';
 import type { BandSlice } from '../../layout/hover';
-import type { LabelAnchor, TextAnchor } from '../../plots/constants';
+import type { LabelAnchor, LineAnchor, TextAnchor } from '../../plots/constants';
 import type { NumberDisplay } from '../../layout/numbers';
 /**
- * Spreads labels that would overlap apart vertically, all reaching out to one
- * shared column, each routed back to its own point by an elbow connector.
- * Unset geometry falls back to the configuration's `text.declutter`.
+ * How labels that would overlap are laid out. `'lanes'` spreads them apart
+ * vertically, all reaching out to one shared column, each routed back to its
+ * own point by an elbow connector; `'around'` puts each one on a free spot
+ * around its point (its own side first, then on clockwise),
+ * clear of the other labels and points, and leaves out one with no room.
  */
+export type TextDeclutterMode = 'lanes' | 'around';
+/** {@link TextDeclutterMode}'s options. Unset geometry falls back to the configuration's `text.declutter`. */
 export type TextDeclutterConfig = {
+    /** Defaults to `'lanes'`. */
+    mode?: TextDeclutterMode;
     /** Shortest lane's distance (px) from the point before a connector bends. */
     elbowGap?: number;
     /** Extra distance (px) each further lane sits out from the last. */
@@ -68,8 +75,10 @@ export type TextMarkerConfig = CommonMarkerConfigWithRowOffset<{
     styles?: PerRow<TextRowStyle> & Omit<FontStyle, TextRowStyleKey>;
     /** Which side of its point the text sits on: a value, or a function of the row. Wins over `styles.textAnchor`. */
     textAnchor?: TextAnchor | ((d: any) => TextAnchor);
-    /** Spreads overlapping labels apart - see {@link TextDeclutterConfig}. `true` takes every default. */
-    declutter?: boolean | TextDeclutterConfig;
+    /** Which side of its point the text sits on vertically: a value, or a function of the row. Wins over `styles.lineAnchor`. */
+    lineAnchor?: LineAnchor | ((d: any) => LineAnchor);
+    /** Lays out overlapping labels - see {@link TextDeclutterConfig}. `true` is `'lanes'` with every default. */
+    declutter?: boolean | TextDeclutterMode | TextDeclutterConfig;
     /** Writes each label to fit its box - see {@link TextFitConfig}. `true` takes every default. */
     fit?: boolean | TextFitConfig;
     /**
@@ -80,6 +89,16 @@ export type TextMarkerConfig = CommonMarkerConfigWithRowOffset<{
     edgeAware?: boolean;
     /** The slice of its category band each label sits in (a grouped bar's series); it is drawn off the band's middle, whatever the band's width. */
     bandSlice?: BandSlice;
+    /**
+     * The shape each row's point sits in: a label is left out where the shape of a row drawn after its own covers it,
+     * as a dot drawn over another hides that one's label.
+     */
+    covers?: (d: any, scales: any) => CoveringShape | undefined;
+    /** How far each row's point sits off its `x`/`y`, in pixels: labels, connectors and lanes start there. */
+    origin?: (d: any, scales: any) => {
+        dx: number;
+        dy: number;
+    } | undefined;
     /** Where, in the plot's frame, a label sits on an axis it sets no position for: `{ type: 'text', x: 5, frameAnchor: 'top' }` is at the frame's top edge. */
     frameAnchor?: LabelAnchor;
     /** Grows the plot's margins, on every side the author left open, so the labels fit. */
@@ -87,21 +106,6 @@ export type TextMarkerConfig = CommonMarkerConfigWithRowOffset<{
     /** Reports how far the rendered labels reach past the plot's content box, in pixels, on each side. */
     onoverflow?: (overflow: Margins) => void;
 } & NumberDisplay & CommonMarkerConfig>;
-/** A `text` marker as a shape's `label`: all of it but what the shape sets - its `type`, its rows and the label's position. */
-export type TextLabelConfig = Omit<TextMarkerConfig, 'type' | 'data' | 'x' | 'y' | 'frameAnchor'> & {
-    /**
-     * Where in its shape the label sits: its `'middle'` (the default), against one of its edges (`'top'`, `'bottom'`,
-     * `'left'`, `'right'`) or in one of its corners (`'top-left'`...). The label's `dx` and `dy` move it from there.
-     */
-    anchor?: LabelAnchor;
-    /**
-     * Puts a label anchored to an edge beyond that edge, outside the shape, instead of inside it. A label out there is not
-     * fitted to the shape, and with `fitMargins` the plot's margins grow to hold it.
-     */
-    outside?: boolean;
-    /** Pixels between the label and the edge it is anchored to. Defaults to the configuration's `text.label.gap`, `4`. */
-    gap?: number;
-};
 export type { LabelAnchor };
 /** Where one decluttered label goes - see `Declutter.buildLanes`. */
 export type LabelLane = {

package/dist/types/markers/channels/commonMarkerConfig.d.ts

@@ -28,6 +28,10 @@ export type CommonMarkerConfig = CommonMarkerEvents & {
     clip?: boolean;
     /** Names the marker on its plot's automatic legend - see {@link MarkLegend}. `false` keeps a decorative marker out of it, and out of how the plot's series look there. */
     legend?: MarkLegend | false;
-    /** Makes the marker a hit area of the plot's hover: the pointer entering any of its shapes hovers its `data` rows. */
-    hover?: boolean;
+    /**
+     * Links the marker to the plot's hover. `'trigger'` makes it a hit area: the pointer entering any of its shapes
+     * hovers its `data` rows. `'style'` has its shapes take the hover marker's `active` and `others` styles.
+     * `true` does both.
+     */
+    hover?: boolean | 'trigger' | 'style';
 };

package/dist/types/markers/channels/commonMarkerConfigWithLabel.d.ts

@@ -1,10 +1,6 @@
-import type { TextLabelConfig } from '../basic/text';
-/** The markers that draw a shape per row, which can write a label in each one. */
-export type CommonMarkerConfigWithLabel = {
-    /**
-     * A label for each shape, written by a `text` marker: every option of one but `type`, `data`, `x` and `y`,
-     * which the shape sets. The label is centred on its shape, and fitted to it unless `fit` is `false` - see
-     * {@link TextFitConfig}. It never takes the pointer from the shape under it.
-     */
-    label?: TextLabelConfig;
+import type { MarkerLabelConfig, MarkerLabels } from '../labels/common';
+/** `TLabel` names the layouts the marker kind supports. */
+export type CommonMarkerConfigWithLabel<TLabel extends MarkerLabelConfig> = {
+    /** One label per shape, or a list of them. `layout` defaults to the marker kind's. */
+    label?: MarkerLabels<TLabel>;
 };

package/dist/types/markers/channels/commonMarkerConfigWithOrientation.d.ts

@@ -0,0 +1,5 @@
+/** A marker drawn by svelteplot's `*X` or `*Y` pair. */
+export type CommonMarkerConfigWithOrientation = {
+    /** Defaults to the plot's way, else to its own channels' when the plot has none. */
+    isHorizontal?: boolean;
+};

package/dist/types/markers/channels/commonMarkerConfigWithOrientation.js

@@ -0,0 +1 @@
+export {};

package/dist/types/markers/common.d.ts

@@ -22,6 +22,7 @@ export * from './axis/trail';
 export * from './axis/waffle';
 export * from './axis/violin';
 export * from './axis/rule';
+export * from './axis/band';
 export * from './axis/hover';
 export * from './axis/component';
 export * from './axis/axisBasedMarkersConfig';

package/dist/types/markers/common.js

@@ -22,6 +22,7 @@ export * from './axis/trail';
 export * from './axis/waffle';
 export * from './axis/violin';
 export * from './axis/rule';
+export * from './axis/band';
 export * from './axis/hover';
 export * from './axis/component';
 export * from './axis/axisBasedMarkersConfig';

package/dist/types/markers/labels/box.d.ts

@@ -0,0 +1,57 @@
+import type { LabelBaseConfig } from './common';
+import type { TextMarkerConfig } from '../basic/text';
+import type { LabelAnchor } from '../../plots/constants';
+/** A label written in the box of each shape, fitted to it unless `fit` is `false`. */
+export type BoxLabelConfig = LabelBaseConfig & {
+    layout?: 'box';
+    anchor?: LabelAnchor;
+    /** Defaults to the configuration's `text.label.gap`. */
+    gap?: number;
+};
+export type BoxShape = 'edges' | 'cell' | 'band';
+/** A field, a symbol, a function of the row or a literal. */
+export type BoxEdge = unknown;
+export type BoxChannels = {
+    x1: BoxEdge;
+    x2: BoxEdge;
+    y1: BoxEdge;
+    y2: BoxEdge;
+};
+export type BoxScales = Record<string, {
+    type?: string;
+    fn: any;
+} | undefined>;
+export type BoxSizer = (row: unknown, scales: BoxScales) => {
+    width: number;
+    height: number;
+} | undefined;
+export type BoxGeometryOf = {
+    x: unknown;
+    y: unknown;
+    box: BoxChannels | BoxSizer;
+    size?: BoxSizer;
+    /** For a shape that runs along a value: the axis it runs on, and where each row starts (its base) and ends (its tip). */
+    ends?: {
+        axis: 'x' | 'y';
+        from: (row: unknown) => unknown;
+        to: (row: unknown) => unknown;
+    };
+};
+export type BoxLabelMarker = {
+    marker: TextMarkerConfig;
+    box: BoxChannels | BoxSizer;
+};
+export type BoxedMarker = {
+    type?: string;
+    data?: unknown[];
+    x?: BoxEdge;
+    y?: BoxEdge;
+    x1?: BoxEdge;
+    x2?: BoxEdge;
+    y1?: BoxEdge;
+    y2?: BoxEdge;
+    isHorizontal?: boolean;
+    role?: string;
+    thickness?: number;
+    styles?: object;
+};

package/dist/types/markers/labels/box.js

@@ -0,0 +1 @@
+export {};

package/dist/types/markers/labels/common.d.ts

@@ -0,0 +1,15 @@
+import type { TextMarkerConfig } from '../basic/text';
+import type { BoxLabelConfig, BoxShape } from './box';
+import type { PointLabelConfig, PointShape } from './point';
+import type { PathLabelConfig, PathShape } from './path';
+export type LabelLayout = 'box' | 'path' | 'point';
+export type LabelBaseConfig = Omit<TextMarkerConfig, 'type' | 'data' | 'x' | 'y' | 'frameAnchor' | 'origin'>;
+export type MarkerLabelConfig = BoxLabelConfig | PathLabelConfig<string, string> | PointLabelConfig;
+export type MarkerLabels<TLabel extends MarkerLabelConfig = MarkerLabelConfig> = TLabel | TLabel[];
+/** The layout a label takes by default, and the geometry the kind gives each layout it supports. */
+export type MarkerLabelTraits = {
+    default: LabelLayout;
+    box?: BoxShape;
+    path?: PathShape;
+    point?: PointShape;
+};

package/dist/types/markers/labels/common.js

@@ -0,0 +1 @@
+export {};

package/dist/types/markers/labels/path.d.ts

@@ -0,0 +1,52 @@
+import type { LabelAnchor } from '../../plots/constants';
+import type { LabelBaseConfig } from './common';
+/** An edge of a shape as it is drawn on the page. */
+export type PageEdge = 'top' | 'bottom' | 'left' | 'right';
+/** An edge of a shape that runs along a value: the end away from zero, `'tip'`, or the one at zero, `'base'`. */
+export type ValueEdge = 'tip' | 'base';
+/** Where a label sits off a closed shape's edge: beyond it, against it within the shape, or centred on it. */
+export type ShapeSide = 'outside' | 'inside' | 'on';
+/** Where a label sits off an open stroke, as its text reads: above it, below it, or centred on it. */
+export type StrokeSide = 'above' | 'below' | 'on';
+/** A label written along an edge of its shape, read per row: a `'tip'` follows the sign of the row's value. */
+export type PathLabelConfig<TEdge extends string = PageEdge | ValueEdge, TSide extends string = ShapeSide> = LabelBaseConfig & {
+    layout: 'path';
+    /** `'tip'` on a shape that runs along a value, else `'top'`. */
+    edge?: TEdge;
+    /** Defaults to `'outside'` on a shape, `'above'` on a stroke. */
+    side?: TSide;
+    /**
+     * Where along the edge, from its left or top end. On a line or an area, `'max'` and `'min'` are the point of each
+     * one with its highest or lowest value - its peak, its trough. Defaults to `'middle'`.
+     */
+    offset?: 'start' | 'middle' | 'end' | 'max' | 'min' | `${number}%`;
+    /** Defaults to the configuration's `text.label.gap`. */
+    gap?: number;
+};
+/** A label written along each line a marker draws, curving with it. */
+export type StrokeLabelConfig = Omit<PathLabelConfig<never, StrokeSide>, 'edge'>;
+/** A label written along the top (`y2`) or bottom (`y1`) edge of each area, curving with it. */
+export type AreaEdgeLabelConfig = PathLabelConfig<'top' | 'bottom', StrokeSide>;
+/** A label written along the rim of each dot, from its left over its top. */
+export type RimLabelConfig = Omit<PathLabelConfig<never, ShapeSide>, 'edge'>;
+/**
+ * Where a kind writes `'path'` labels: `'box'` along the edges of each row's box, `'stroke'` along each line it
+ * draws, `'area'` along the top or bottom edge of each area, `'rim'` around each dot.
+ */
+export type PathShape = 'box' | 'stroke' | 'area' | 'rim';
+/** Where a plot's value label goes on its shape: in its box at an `anchor`, or along one of its edges. */
+export type ShapePlacement = {
+    anchor: LabelAnchor;
+} | Required<Pick<PathLabelConfig, 'layout' | 'edge' | 'side'>>;
+/** One label along a curve, in pixels: the path its text follows and where on it the text sits. */
+export type CurvedLabel = {
+    d: string;
+    text: string;
+    /** A row it labels: the row of a dot, the first of a line. */
+    row: unknown;
+    startOffset: string;
+    textAnchor: 'start' | 'middle' | 'end';
+    dy: number;
+    baseline: 'auto' | 'hanging' | 'central';
+    fill?: string;
+};

package/dist/types/markers/labels/path.js

@@ -0,0 +1 @@
+export {};

package/dist/types/markers/labels/point.d.ts

@@ -0,0 +1,40 @@
+import type { LabelBaseConfig } from './common';
+import type { ValueSelect } from '../../layout/styles';
+import type { LabelAnchor } from '../../plots/constants';
+import type { BoxScales, BoxSizer } from './box';
+/** A label written beside a point of its shape, spread apart from the others with `declutter`. */
+export type PointLabelConfig = LabelBaseConfig & {
+    layout?: 'point';
+    /** The rows labelled, of each `grouping` of the marker. Every row by default. */
+    select?: ValueSelect | ValueSelect[] | ((row: any) => boolean);
+    /** On a shape with a box (a bar, a cell): the point of its box the label starts at, `'middle'` by default. */
+    anchor?: LabelAnchor;
+    /** Which side of its point the text is written on, as it reads: after it (to its right), before it, above, below or on it. */
+    side?: PointSide;
+    /** The gap from its point. Defaults to the configuration's `text.label.gap` on a box, else 6px across and 8px up or down. */
+    gap?: number;
+};
+export type PointSide = 'after' | 'before' | 'above' | 'below' | 'on';
+/**
+ * `'row'` labels each row at its `x`/`y`; `'top'` at its `x`/`y2` (a stacked area); `'box'` at a point of its box;
+ * `'dot'` at its center, in a round shape of its radius.
+ */
+export type PointShape = 'row' | 'top' | 'box' | 'dot';
+/** Where a marker's rows are labelled; `size` is the shape around each point, when it has one, `round` a circle in it. */
+export type PointGeometryOf = {
+    x: unknown;
+    y: unknown;
+    size?: BoxSizer;
+    round?: boolean;
+    /** How far each row's point sits off its `x`/`y`, in pixels: a series' own slot of its category's band. */
+    shift?: (row: unknown, scales: BoxScales) => {
+        dx: number;
+        dy: number;
+    } | undefined;
+};
+/** The shape a row's point sits in, in pixels around it: a box, or the circle in it. */
+export type CoveringShape = {
+    width: number;
+    height: number;
+    round?: boolean;
+};

package/dist/types/markers/labels/point.js

@@ -0,0 +1 @@
+export {};

package/dist/types/markers/traits.d.ts

@@ -1,4 +1,8 @@
+import type { ChannelName } from '../layout/mapping';
 import type { LegendMark } from '../layout/legend';
+import type { MarkerLabelTraits } from './labels/common';
+/** A plot channel a marker can take from its plot; `x`/`y` are each taken only by a marker setting no position on that axis. */
+export type InheritedChannel = Exclude<ChannelName, 'value'>;
 /** What the rest of the system needs to know about a marker kind, declared once per kind in `MarkerKinds`. */
 export type MarkerTraits = {
     /**
@@ -19,4 +23,10 @@ export type MarkerTraits = {
      * dot, an area, a bar... A marker without one shows as a plain swatch.
      */
     legendSymbol?: LegendMark;
+    /** The plot's channels the marker takes in place of those it leaves unset, with the plot's scales for those that have one. */
+    inherits?: InheritedChannel[];
+    /** Whether it runs one way or the other (svelteplot's `*X`/`*Y` pair): the plot's way, else its own channels'. */
+    oriented?: boolean;
+    /** The labels the marker can write over its shapes; none without it. */
+    labels?: MarkerLabelTraits;
 };

package/dist/types/phases/context/phase.d.ts

@@ -0,0 +1,7 @@
+/**
+ * What a plot kind works out for each of its processed rows beyond the shared context (its series, `x`, `y` and
+ * value): a tile's share, a bin's edges, a box's quartiles. Given the state once, it returns a function of a row,
+ * so whatever the rows share (a total, a box's summary) is worked out once. What it returns is laid over the
+ * shared context, so it can also replace the `value` a row shows.
+ */
+export type ContextStageOptions<TState, TEnv = unknown> = (state: TState, env: TEnv) => (row: never) => object | undefined;

package/dist/types/phases/context/phase.js

@@ -0,0 +1 @@
+export {};

package/dist/types/phases/data/phase.d.ts

@@ -15,7 +15,7 @@ export type SegmentsStageOptions = {
  * which channels the author set, what each axis is, which way the plot runs,
  * whether `color` groups - the stage reads off the data itself.
  */
-export type DataStageOptions<TState, TCtx> = {
+export type DataStageOptions<TState, TEnv> = {
     /** How many axes the kind lays out as categories: 0 (line), 1 (bar) or 2 (heatmap). Defaults to 0. */
     discreteAxes?: DiscreteAxesCount;
     /** How the kind's own mark splits into visual segments. */
@@ -30,5 +30,5 @@ export type DataStageOptions<TState, TCtx> = {
      */
     nested?: boolean;
     /** The plot's own extra "data" output, once the shared one is in place. */
-    extend?: (state: TState, ctx: TCtx) => TState;
+    extend?: (state: TState, env: TEnv) => TState;
 };

package/dist/types/phases/hover/phase.d.ts

@@ -1,5 +1,6 @@
 import type { HoverDisplayPoint, HoverStrategy } from '../../layout/hover';
 import type { HoverConfig, PointMatchingStrategy } from '../../plots/props';
+import type { HoverLook } from '../../markers/common';
 /** Where a row sits for hover matching and the hover controller: its `x` and `y`. */
 export type HoverPosition = {
     x: (row: never) => unknown;
@@ -11,7 +12,7 @@ export type HoverPosition = {
  * row or a cell outside the legend's range can't), the rows themselves and
  * their series' colors - the stage reads off the plot's own state.
  */
-export type HoverStageOptions<TState, TCtx = unknown> = {
+export type HoverStageOptions<TState, TEnv = unknown> = {
     /**
      * The hover strategy, when the plot's axes don't say it: along the axis
      * that isn't measured, or `'punctual'` with both axes holding categories.
@@ -27,16 +28,18 @@ export type HoverStageOptions<TState, TCtx = unknown> = {
     position?: (state: TState) => HoverPosition;
     /** The short label drawn next to a hovered row. Defaults to its value. */
     label?: (state: TState) => (row: never) => string;
-    /** What a hovered row reads as, e.g. with derived fields added. Defaults to the processed row. */
-    row?: (state: TState) => (row: never) => unknown;
     /** Fields a candidate carries besides its place, label and series color (a grouped bar's `dx`/`dy`). */
-    decorate?: (state: TState, ctx: TCtx) => (row: never) => Partial<Omit<HoverDisplayPoint, 'x' | 'y' | 'label'>>;
+    decorate?: (state: TState, env: TEnv) => (row: never) => Partial<Omit<HoverDisplayPoint, 'x' | 'y' | 'label'>>;
     /** Invisible markers that drive the plot's hover themselves (a bar's band), given its resolved hover config. */
-    hitAreas?: (state: TState, hover: HoverConfig<any>, ctx: TCtx) => {
+    hitAreas?: (state: TState, hover: HoverConfig<any>, env: TEnv) => {
         type: string;
     }[];
-    /** What the kind knows of a row beyond its series, which an author's own tooltip `format` gets in its third argument. */
-    context?: (state: TState) => (row: never) => object;
     /** How a pointer event resolves to a candidate. Defaults to the nearest one. */
     pointMatching?: PointMatchingStrategy;
+    /**
+     * The kind's own hover, which an author's `hover` marker is laid over - one look, or one for each strategy, as
+     * the strategy in force can change while the plot is shown (a composer's, a scrolly step's). Defaults to a
+     * crosshair along the axes the strategy matches along, and a dot and a label on each point.
+     */
+    marker?: (state: TState, env: TEnv) => HoverLook | ((strategy: HoverStrategy) => HoverLook);
 };

package/dist/types/phases/index.d.ts

@@ -1,10 +1,11 @@
 export type { PlotPhase, PhaseStage } from './stage';
-export type { AxisPlotState, AxisPlotCtx } from './state';
+export type { AxisPlotState, AxisPlotEnv } from './state';
 export type { AxisPlotKind, AxisPlotDefaults, SharedScalesOptions } from './kind';
 export type { DataRunState } from './pipeline';
 export type { DataStageOptions } from './data/phase';
 export type { MappingStageOptions } from './mapping/phase';
 export type { ProcessedRow, ProcessedChannel, ProcessedChannelName, ProcessedData, TransformsStageState, TransformsStageOptions } from './transforms/phase';
+export type { ContextStageOptions } from './context/phase';
 export type { StatisticsStageState, StatisticsStageOptions } from './statistics/phase';
 export type { SharedAxisValues } from './sharedScales/phase';
 export type { AxisFit, ScalesStageOptions } from './scales/phase';

package/dist/types/phases/kind.d.ts

@@ -4,6 +4,7 @@ import type { TransformsStageOptions, TransformsStageState } from './transforms/
 import type { StatisticsStageOptions, StatisticsStageState } from './statistics/phase';
 import type { ScalesStageOptions } from './scales/phase';
 import type { HoverStageOptions } from './hover/phase';
+import type { ContextStageOptions } from './context/phase';
 import type { StylesStageOptions } from './styles/phase';
 import type { MarkersStageOptions } from './markers/phase';
 import type { AxisChannelName, ChannelName } from '../layout/mapping';
@@ -12,15 +13,17 @@ import type { AxisRole } from './data/axes';
  * What one axis-based plot kind adds to the shared pipeline: options for each
  * shared stage - its own marks and value labels among them.
  */
-export type AxisPlotKind<TState extends TransformsStageState & StatisticsStageState, TCtx> = {
-    data?: DataStageOptions<TState, TCtx>;
-    mapping?: MappingStageOptions<TState, TCtx>;
-    transforms?: TransformsStageOptions<TState, TCtx>;
+export type AxisPlotKind<TState extends TransformsStageState & StatisticsStageState, TEnv> = {
+    data?: DataStageOptions<TState, TEnv>;
+    mapping?: MappingStageOptions<TState, TEnv>;
+    transforms?: TransformsStageOptions<TState, TEnv>;
+    /** What the kind works out for each of its rows, for everything that writes about a row to read - see `RowContext`. */
+    context?: ContextStageOptions<TState, TEnv>;
     statistics?: StatisticsStageOptions<TState>;
-    scales?: ScalesStageOptions<TState, TCtx>;
+    scales?: ScalesStageOptions<TState, TEnv>;
     styles?: StylesStageOptions<TState>;
-    markers: MarkersStageOptions<TState, TCtx>;
-    hover?: HoverStageOptions<TState, TCtx>;
+    markers: MarkersStageOptions<TState, TEnv>;
+    hover?: HoverStageOptions<TState, TEnv>;
     /**
      * How the slices of a plot (facet panels, timeline steps) share their
      * domains. Every axis kind shares them - bands from its axes, zero from its
@@ -42,7 +45,7 @@ export type SharedScalesOptions = {
  * runs with: the options for each pipeline phase (its hover among them),
  * plus how its plot tweens a timeline unless the author says otherwise.
  */
-export type AxisPlotDefaults<TState extends TransformsStageState & StatisticsStageState, TCtx> = AxisPlotKind<TState, TCtx> & {
+export type AxisPlotDefaults<TState extends TransformsStageState & StatisticsStageState, TEnv> = AxisPlotKind<TState, TEnv> & {
     timeline?: {
         /** Default for `timeline.filterMode`. */
         filterMode?: 'exact' | 'upTo';

package/dist/types/phases/mapping/phase.d.ts

@@ -1,5 +1,5 @@
 /** What differs between plots in the shared "mapping" stage. */
-export type MappingStageOptions<TState, TCtx> = {
+export type MappingStageOptions<TState, TEnv> = {
     /** The plot's own extra "mapping" output, once every channel is resolved. */
-    extend?: (state: TState, ctx: TCtx) => TState;
+    extend?: (state: TState, env: TEnv) => TState;
 };

package/dist/types/phases/markers/phase.d.ts

@@ -1,13 +1,6 @@
-import type { ValueLabels } from '../../../layout/styles/ValueLabels';
-import type { AxisBasedMarkersConfig, TextMarkerConfig } from '../../markers/common';
+import type { AxisBasedMarkersConfig } from '../../markers/common';
 /** What a plot kind adds to the shared "markers" stage. */
-export type MarkersStageOptions<TState, TCtx> = {
+export type MarkersStageOptions<TState, TEnv> = {
     /** The plot's own marks - its bars, lines, dots... - drawn under every other marker. */
-    marks: (state: TState, ctx: TCtx) => AxisBasedMarkersConfig[];
-    /**
-     * Its value labels, once they show: `text` markers drawn over everything.
-     * The stage adds what every label shares - see {@link ValueLabels.hooks}.
-     * Without it, the plot draws none.
-     */
-    valueLabels?: (labels: ValueLabels, state: TState, ctx: TCtx) => TextMarkerConfig[];
+    marks: (state: TState, env: TEnv) => AxisBasedMarkersConfig[];
 };

package/dist/types/phases/scales/phase.d.ts

@@ -13,7 +13,7 @@ export type AxisFit = Partial<AnyAxisScale> & {
  * numeric axis to cover derived markers and transformed ranges; these say
  * where a kind goes beyond that.
  */
-export type ScalesStageOptions<TState, TCtx> = {
+export type ScalesStageOptions<TState, TEnv> = {
     /** Axes whose marks grow from zero, so a domain this stage sets still reaches it - by name or by role (`'value'`). */
     zero?: AxisRef[];
     /** Axes that reach as far below zero as above it, to the largest magnitude - by name or by role. */
@@ -21,10 +21,10 @@ export type ScalesStageOptions<TState, TCtx> = {
     /** Keeps a category axis in the order the data gives it. Without it, categories sort ascending, as svelteplot does. */
     bandOrder?: 'data';
     /** The kind's own options for an axis, by name or by role, under the author's `scales`: padding, label anchor, tick format. */
-    defaults?: (state: TState, ctx: TCtx) => Partial<Record<AxisRef, AnyAxisScale>>;
+    defaults?: (state: TState, env: TEnv) => Partial<Record<AxisRef, AnyAxisScale>>;
     /** The options the kind fits to its own marks on an axis the author left unpinned - a niced value axis, a domain padded for its dots. */
-    fit?: (state: TState, ctx: TCtx) => Partial<Record<AxisChannelName, AxisFit>>;
+    fit?: (state: TState, env: TEnv) => Partial<Record<AxisChannelName, AxisFit>>;
     /** The kind's own extra "scales" output, once every scale is in place. */
-    extend?: (state: TState, ctx: TCtx) => TState;
+    extend?: (state: TState, env: TEnv) => TState;
 };
 export {};

package/dist/types/phases/stage.d.ts

@@ -4,9 +4,9 @@
  * of a plot shares, `tooltip`, how a hovered row reads once
  * everything it reads from is placed, and `hover`, what the pointer can match.
  */
-export type PlotPhase = 'facet' | 'data' | 'mapping' | 'transforms' | 'statistics' | 'sharedScales' | 'scales' | 'styles' | 'markers' | 'coordinates' | 'tooltip' | 'hover';
+export type PlotPhase = 'facet' | 'data' | 'mapping' | 'transforms' | 'context' | 'statistics' | 'sharedScales' | 'scales' | 'styles' | 'markers' | 'coordinates' | 'tooltip' | 'hover';
 /** A resolution step for one {@link PlotPhase} - same state shape in and out. Each shared phase is a class (`DataPhase`, `HoverPhase`...) that implements it. */
-export type PhaseStage<TState, TCtx = unknown> = {
+export type PhaseStage<TState, TEnv = unknown> = {
     phase: PlotPhase;
-    run: (state: TState, ctx: TCtx) => TState;
+    run: (state: TState, env: TEnv) => TState;
 };

package/dist/types/phases/state.d.ts

@@ -91,7 +91,7 @@ export type AxisPlotState<TData extends Record<string, unknown>, TStyle extends
     hoverRows?: unknown[];
 };
 /** The environment every axis-based plot's phases read from, alongside the growing state. */
-export type AxisPlotCtx = {
+export type AxisPlotEnv = {
     cfg: PlotStylesConfig;
     /** The legend's toggles and the figure's hover, read for one plot: which series show and how each dims. */
     interaction?: PlotInteraction;

package/dist/types/phases/statistics/phase.d.ts

@@ -1,6 +1,6 @@
 import type { ScopedMarkerGroup } from '../../layout/geometry';
 import type { Accessor, Series } from '../../plots/data/common';
-import type { AxisValue } from '../../layout/mapping';
+import type { AxisChannelName, AxisValue } from '../../layout/mapping';
 import type { StatisticConfig } from '../../layout/statistics';
 import type { AxisBasedMarkersConfig } from '../../markers/common';
 import type { ProcessedData, TransformsStageState } from '../transforms/phase';
@@ -16,10 +16,17 @@ export type StatisticsStageState = Pick<FacetStageState, 'panels'> & {
     /** The key the "data" phase split the rows into series by, which an author marker inherits. */
     seriesGrouping?: Accessor<any, unknown>;
     color?: Accessor<any, unknown>;
+    opacity?: Accessor<any, unknown>;
+    symbol?: Accessor<any, unknown>;
+    r?: number | Accessor<any, number>;
+    length?: number | Accessor<any, number>;
     statistics?: StatisticConfig[];
     authorMarkers?: AxisBasedMarkersConfig[];
     resolvedSeries?: Series<any>[];
     axes?: PlotAxes;
+    scales?: Partial<Record<AxisChannelName, {
+        type?: string;
+    }>>;
     flat?: any[];
     colorForSeries?: (name: string) => string;
     /** Each series' segments, which a `scope: 'segment'` author marker splits by. */
@@ -39,6 +46,4 @@ export type StatisticsStageOptions<TState extends StatisticsStageState> = {
      * default; off for a plot whose `color` is a value channel, not a group.
      */
     inheritGrouping?: boolean;
-    /** Whether a line/area/dot author marker with no `x`/`y` takes the plot's own. */
-    inheritPositions?: boolean;
 };