@fundar/data-chart-telling 1.16.0 → 1.18.0

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

@@ -57,6 +57,11 @@ export type AxisPlotState<TData extends Record<string, unknown>, TStyle extends
     /** What each position channel is, which one holds the categories, and which way the plot runs. */
     axes?: PlotAxes;
     resolvedSeries?: TSeries[];
+    /** The series the legend took out of the rows, and how (`'omit'` or `'rescale'`): a part of a whole still reads its whole from them. */
+    removedSeries?: {
+        mode: 'omit' | 'rescale';
+        series: TSeries[];
+    };
     seriesGrouping?: Accessor<any, unknown>;
     /** Every series name, before legend-omitted ones are dropped, so colors stay put. */
     allSeriesNames?: string[];
@@ -66,6 +71,8 @@ export type AxisPlotState<TData extends Record<string, unknown>, TStyle extends
     flat?: TRow[];
     scopedGroups?: ScopedMarkerGroup<TData>[];
     colorForSeries?: (name: string) => string;
+    /** The color of a path of the `grouping` levels, outermost first, while `scales.color.depth` reaches past the outermost (see `ColorTones.hierarchy`). */
+    colorForPath?: (path: readonly string[]) => string;
     /** A discrete mark's gap fills, per series id: the value each missing row is drawn at. */
     gapFillMaps?: Map<string, Map<TData, DiscreteGapFill<TStyle>>>;
     channels?: ResolvedChannels<TData>;
@@ -84,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

@@ -13,7 +13,8 @@ import type { PlotAxes } from '../../../phases/data/PlotAxes';
 export type StatisticsStageState = Pick<FacetStageState, 'panels'> & {
     x?: Accessor<any, AxisValue>;
     y?: Accessor<any, AxisValue>;
-    grouping?: Accessor<any, unknown>;
+    /** The key the "data" phase split the rows into series by, which an author marker inherits. */
+    seriesGrouping?: Accessor<any, unknown>;
     color?: Accessor<any, unknown>;
     statistics?: StatisticConfig[];
     authorMarkers?: AxisBasedMarkersConfig[];

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

@@ -1,3 +1,4 @@
+import type { PlotRowContext } from '../../layout/context';
 import type { EdgeBox } from '../../layout/box';
 import type { ValueLabels } from '../../../layout/styles/ValueLabels';
 import type { ValueAnchor } from '../../plots/constants';
@@ -7,8 +8,8 @@ export type ValueLabelsOptions<TState> = {
     show?: boolean;
     /** Where a label sits when `styles.values.anchor` is unset. Defaults to `'outside'`. */
     anchor?: ValueAnchor;
-    /** A label's text when `styles.values.format` is unset. Defaults to the bare value. `number` writes a value as the plot's `styles.values` display fields (`decimals`, `prefix`, `suffix`, `signDisplay`) ask. */
-    format?: (value: number, seriesName: string, number: (value: number) => string) => string;
+    /** A label's text when `styles.values.format` is unset. Defaults to the bare value. `number` writes a value as the plot's `styles.values` display fields (`decimals`, `prefix`, `suffix`, `signDisplay`) ask, and `context` is what the plot knows of the labelled row. */
+    format?: (value: number, number: (value: number) => string, context: PlotRowContext) => string;
     /**
      * Where the labels are expected to sit, from the whole data: boxes around
      * the points they label, on the plot edges those points can reach (see

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

@@ -26,6 +26,11 @@ export type ProcessedData = {
 /** What the shared "transforms" stage reads from and writes to a plot's state. */
 export type TransformsStageState = {
     resolvedSeries?: Series<any>[];
+    /** The series the legend took out of the rows, and how. */
+    removedSeries?: {
+        mode: 'omit' | 'rescale';
+        series: Series<any>[];
+    };
     /** The style every segment of a series is drawn over, which the processed groups are cut with too. */
     segmentBase?: (series: string) => any;
     axes?: PlotAxes;
@@ -46,9 +51,15 @@ export type TransformsStageState = {
     processedGroups?: VisualGroup<Series<ProcessedRow>, any>[];
 };
 /** What differs between plots in the shared "transforms" stage. */
-export type TransformsStageOptions<TState extends TransformsStageState, TCtx> = {
+export type TransformsStageOptions<TState extends TransformsStageState, TEnv> = {
     /** The transforms to run. Defaults to the plot's own `transforms`. */
-    transforms?: (state: TState, ctx: TCtx) => MarkerTransform[];
+    transforms?: (state: TState, env: TEnv) => MarkerTransform[];
+    /**
+     * Whether a series the legend omits keeps its part of the whole (a treemap's tile): the transforms run over
+     * its rows too, so every other part keeps its share and its place, and its own rows are dropped after.
+     * Unset, an omitted series is not there for the transforms at all (a stack closes over it).
+     */
+    keepsOmitted?: boolean;
     /**
      * How the processed rows split into `processedGroups`: one group per series
      * (the default), or `'runs'` of consecutive rows from the same series, in

package/dist/types/plots/constants.d.ts

@@ -1,20 +1,20 @@
 /**
- * Unified positional anchor for value labels across all plot kinds.
- *
- * - `'outside'` - beyond the tip of the mark (above a vertical bar, to the
- *   far end of a horizontal bar or line). This is the only value with no
- *   direct svelteplot equivalent; the plot computes dx/dy internally.
- * - `'start'` - at the tip of the mark, just inside (top of a bar, far end
- *   of a pyramid bar from zero, right of a line's last point).
- * - `'middle'` - centred on the mark.
- * - `'end'` - at the baseline/zero end of the mark.
+ * Where something sits in a box, in a frame or on a shape: its middle, against one of its edges as they are drawn on
+ * the page, or in one of its corners. The anchors of a text marker's `frameAnchor`, and of a shape's `label`.
+ */
+export type LabelAnchor = 'middle' | 'top' | 'bottom' | 'left' | 'right' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+/**
+ * Where a value label sits on its mark. Two vocabularies share the type, one per family of plots:
  *
- * On a bar plot the anchors read as the bars are drawn, whatever the sign of the value: `'outside'` is
- * beyond the tip (left of a horizontal bar below zero, under a vertical one), `'start'` the left end of a
- * horizontal bar or the top end of a vertical one, `'end'` the right or bottom end, both inside, and
- * `'middle'` the centre.
+ * - The plots that label a point or the end of a line (`LinePlot`, `AreaPlot`, `SlopePlot`, `ScatterPlot`...) read
+ *   the side of the point its text is written on: `'start'` after it (right of a line's last point), `'end'` before
+ *   it, `'middle'` on it and `'outside'` beyond it.
+ * - The plots that label a shape (`BarPlot`, `BulletPlot`, `PyramidPlot`, `HistogramPlot`) read where in it the
+ *   label is. Inside the shape: a {@link LabelAnchor} - its `'middle'`, an edge as it is drawn on the page
+ *   (`'top'`, `'left'`...) or a corner (`'top-left'`...) - or, whichever side of zero the value is, the end of the bar
+ *   away from zero, `'tip'`, or the one at zero, `'base'`. Beyond the tip, outside the shape: `'outside'`.
  */
-export type ValueAnchor = 'outside' | 'start' | 'middle' | 'end';
+export type ValueAnchor = LabelAnchor | 'outside' | 'start' | 'end' | 'tip' | 'base';
 /**
  * Shared by two unrelated renderers: a `dot` mark's own point shape
  * (delegated to svelteplot/d3-shape) and a discrete legend item's own icon
@@ -32,11 +32,9 @@ export type FontWeight = 'normal' | 'bold' | number;
 /** `font-style` keyword accepted by any text styling. */
 export type FontStyleKeyword = 'normal' | 'italic';
 /**
- * Horizontal text anchor. `'outside'` is only meaningful where the consuming
- * mark resolves it per-point from a signed x value (currently `HoverMarker`
- * only) - it anchors the label away from zero: `'start'` (extending right)
- * for a positive x, `'end'` (extending left) for negative. Elsewhere it's
- * treated the same as `'start'`.
+ * Horizontal text anchor. `'outside'` leaves the side to the mark that writes
+ * the label, where it picks one per point (a Cleveland plot's labels take
+ * their own); elsewhere it's treated the same as `'start'`.
  */
 export type TextAnchor = 'start' | 'middle' | 'end' | 'outside';
 /** Vertical text anchor. */

package/dist/types/plots/correlation/heatmap/props.d.ts

@@ -1,10 +1,10 @@
 import type { BasePlotProps, PlotCoreProps } from '../../props';
 import type { AxisBasedScalesConfig } from '../../../layout/scales';
 import type { AxisBasedMarkersConfig } from '../../../markers/common';
-import type { SeriesProps, DataProps } from '../../data/common';
+import type { SeriesProps, DualAxisDataProps } from '../../data/common';
 import type { AxisBasedStylesConfig } from '../../../layout/styles';
 import type { CellSegmentStyle } from '../../segments/common';
 /** `HeatmapPlot`'s public props. */
-export type HeatmapPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DataProps<TData>, TData, AxisBasedStylesConfig, CellSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export type HeatmapPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DualAxisDataProps<TData>, TData, AxisBasedStylesConfig, CellSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
 /** What `HeatmapPlot`'s core draws from. */
-export type HeatmapPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DataProps<TData>, TData, AxisBasedStylesConfig, CellSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export type HeatmapPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DualAxisDataProps<TData>, TData, AxisBasedStylesConfig, CellSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;

package/dist/types/plots/correlation/heatmap/state.d.ts

@@ -1,7 +1,7 @@
 import type { CellSegmentStyle } from '../../segments/common';
 import type { ResolvedChannel, ResolvedChannels } from '../../../layout/mapping';
 import type { LegendRange } from '../../../layout/legend';
-import type { AxisPlotState, AxisPlotCtx } from '../../../phases';
+import type { AxisPlotState, AxisPlotEnv } from '../../../phases';
 /**
  * The active continuous-legend range filter, if any - narrows which cells
  * render at full opacity, and in `'rescale'` mode, the color domain itself.
@@ -23,6 +23,6 @@ export type HeatmapPlotState<TData extends Record<string, unknown>> = AxisPlotSt
     resolveOpacity?: (row: TData) => number;
 };
 /** The environment every HeatmapPlot phase reads from, alongside the growing state. */
-export type HeatmapPlotCtx = AxisPlotCtx & {
+export type HeatmapPlotEnv = AxisPlotEnv & {
     range: HeatmapRangeFilter | null | undefined;
 };

package/dist/types/plots/correlation/scatter/props.d.ts

@@ -1,10 +1,10 @@
 import type { BasePlotProps, PlotCoreProps } from '../../props';
 import type { AxisBasedScalesConfig } from '../../../layout/scales';
 import type { AxisBasedMarkersConfig } from '../../../markers/common';
-import type { SeriesProps, DataProps } from '../../data/common';
+import type { SeriesProps, DualAxisDataProps } from '../../data/common';
 import type { AxisBasedStylesConfig } from '../../../layout/styles';
 import type { ScatterSegmentStyle } from '../../segments/common';
 /** `ScatterPlot`'s public props. */
-export type ScatterPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DataProps<TData>, TData, AxisBasedStylesConfig, ScatterSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export type ScatterPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DualAxisDataProps<TData>, TData, AxisBasedStylesConfig, ScatterSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
 /** What `ScatterPlot`'s core draws from. */
-export type ScatterPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DataProps<TData>, TData, AxisBasedStylesConfig, ScatterSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export type ScatterPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DualAxisDataProps<TData>, TData, AxisBasedStylesConfig, ScatterSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;

package/dist/types/plots/correlation/scatter/state.d.ts

@@ -1,6 +1,6 @@
 import type { ScatterSegmentStyle } from '../../segments/common';
-import type { AxisPlotState, AxisPlotCtx } from '../../../phases';
+import type { AxisPlotState, AxisPlotEnv } from '../../../phases';
 /** ScatterPlot's pipeline state: the shared axis-based state, with no extras of its own. */
 export type ScatterPlotState<TData extends Record<string, unknown>> = AxisPlotState<TData, ScatterSegmentStyle>;
 /** The environment every ScatterPlot phase reads from, alongside the growing state. */
-export type ScatterPlotCtx = AxisPlotCtx;
+export type ScatterPlotEnv = AxisPlotEnv;

package/dist/types/plots/data/common.d.ts

@@ -1,4 +1,4 @@
-import type { AxisValue, AxisChannelName, ChannelAccessors } from '../../layout/mapping';
+import type { AxisValue, AxisChannelName, ChannelAccessors, ChannelName } from '../../layout/mapping';
 /**
  * A field key or accessor function. Mirrors the shorthand used across plots
  * so chart-level encodings (`x`, `y`, `color`, facet, timeline) feel
@@ -27,7 +27,7 @@ export type Series<T extends Record<string, unknown> = Record<string, unknown>>
 /** The channels a pre-built {@link Series} carries itself, so a plot given `series` takes none of them. */
 type SeriesChannelName = AxisChannelName | 'color' | 'grouping';
 /**
- * Pre-built series. Mutually exclusive with {@link DataProps} - takes
+ * Pre-built series. Mutually exclusive with the data props ({@link DualAxisDataProps}...) - takes
  * precedence when both could apply. Any channel a series doesn't carry
  * itself is still a plot-level prop.
  */
@@ -37,12 +37,25 @@ export type SeriesProps<T extends Record<string, unknown>> = {
 } & {
     [K in SeriesChannelName]?: never;
 } & Omit<ChannelAccessors<T>, SeriesChannelName>;
+/** The channels of `TRequired` as required props. */
+type RequiredChannels<T extends Record<string, unknown>, TRequired extends ChannelName> = Required<Pick<ChannelAccessors<T>, TRequired>>;
 /**
- * Flat rows to group into series, as an alternative to {@link SeriesProps}.
- * Takes every channel; `x`/`y` are required.
+ * Flat rows to group into series, as an alternative to {@link SeriesProps}, on a plot with no axes (a treemap):
+ * every channel but the position ones. `TRequired` names the channels the plot cannot draw without. The base of
+ * {@link SingleAxisDataProps} and {@link DualAxisDataProps}.
  */
-export type DataProps<T extends Record<string, unknown>> = {
+export type NonAxisDataProps<T extends Record<string, unknown>, TRequired extends Exclude<ChannelName, AxisChannelName> = never> = {
     series?: never;
     data: T[];
-} & ChannelAccessors<T> & Required<Pick<ChannelAccessors<T>, AxisChannelName>>;
+    x?: never;
+    y?: never;
+} & Omit<ChannelAccessors<T>, AxisChannelName> & RequiredChannels<T, TRequired>;
+/** Flat rows on one axis (a histogram): `x`, or `y` alone, besides every other channel. */
+export type SingleAxisDataProps<T extends Record<string, unknown>, TRequired extends Exclude<ChannelName, AxisChannelName> = never> = Omit<NonAxisDataProps<T, TRequired>, AxisChannelName> & ((RequiredChannels<T, 'x'> & {
+    y?: never;
+}) | (RequiredChannels<T, 'y'> & {
+    x?: never;
+}));
+/** Flat rows on both axes: `x` and `y`, besides every other channel. */
+export type DualAxisDataProps<T extends Record<string, unknown>, TRequired extends Exclude<ChannelName, AxisChannelName> = never> = Omit<NonAxisDataProps<T, TRequired>, AxisChannelName> & RequiredChannels<T, AxisChannelName>;
 export {};

package/dist/types/plots/data/geo.d.ts

@@ -25,7 +25,7 @@ export type Topology = {
     bbox?: number[];
 };
 /**
- * Data contract for GeoPlot - the geo analog of {@link DataProps}/{@link SeriesProps}
+ * Data contract for GeoPlot - the geo analog of {@link DualAxisDataProps}/{@link SeriesProps}
  * (`$lib/types/plots/data/common`). There's no x/y axis pair for geographic data:
  * `data` IS the map.
  */

package/dist/types/plots/distribution/box/props.d.ts

@@ -1,10 +1,32 @@
+import type { KindRowContext } from '../../../layout/context';
+import type { AxisValue } from '../../../layout/mapping';
 import type { BasePlotProps, PlotCoreProps } from '../../props';
 import type { AxisBasedScalesConfig } from '../../../layout/scales';
 import type { AxisBasedMarkersConfig } from '../../../markers/common';
-import type { SeriesProps, DataProps } from '../../data/common';
+import type { SeriesProps, DualAxisDataProps } from '../../data/common';
 import type { AxisBasedStylesConfig } from '../../../layout/styles';
 import type { AreaStyle } from '../../styling';
+/**
+ * One box's summary: its category, its quartiles, the whisker ends (the farthest values within 1.5 IQR of the box),
+ * how many values it has and the ones past the whiskers.
+ */
+export type BoxSummary = {
+    category: AxisValue;
+    min: number;
+    p25: number;
+    median: number;
+    p75: number;
+    max: number;
+    count: number;
+    outliers: number[];
+};
+/**
+ * What a `BoxPlot` or a `ViolinPlot` knows of a row, which its tooltip's and value labels' `format`, its hover and
+ * `usePlot().contextOf` read: the summary of the box (or violin) it is in. A value's own `value` stays its own; a
+ * hovered box's is its median.
+ */
+export type BoxRowContext = KindRowContext<BoxSummary>;
 /** `BoxPlot`'s public props. */
-export type BoxPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DataProps<TData>, TData, AxisBasedStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export type BoxPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DualAxisDataProps<TData>, TData, AxisBasedStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>, undefined, BoxRowContext>;
 /** What `BoxPlot`'s core draws from. */
-export type BoxPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DataProps<TData>, TData, AxisBasedStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export type BoxPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DualAxisDataProps<TData>, TData, AxisBasedStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;

package/dist/types/plots/distribution/box/state.d.ts

@@ -1,23 +1,12 @@
 import type { AreaStyle } from '../../styling';
-import type { AxisPlotState, AxisPlotCtx, ProcessedRow } from '../../../phases';
-import type { AxisValue } from '../../../layout/mapping';
+import type { AxisPlotState, AxisPlotEnv, ProcessedRow } from '../../../phases';
+import type { BoxSummary } from './props';
 /** BoxPlot's pipeline state: the shared axis-based state, with no extras of its own. */
 export type BoxPlotState<TData extends Record<string, unknown>> = AxisPlotState<TData, AreaStyle>;
 /** The environment every BoxPlot phase reads from, alongside the growing state. */
-export type BoxPlotCtx = AxisPlotCtx;
+export type BoxPlotEnv = AxisPlotEnv;
 /**
- * One box's summary - what a hovered box reads as: its category, its
- * quartiles, the whisker ends (the farthest values within 1.5 IQR of the
- * box) and the values past them. It also keeps the series tags and, when the
- * category channel is a field key, the category under that field.
+ * One box's summary as a row - what a hovered box reads as. It also keeps the series tags and, when the category
+ * channel is a field key, the category under that field.
  */
-export type BoxSummaryRow = ProcessedRow & {
-    category: AxisValue;
-    min: number;
-    p25: number;
-    median: number;
-    p75: number;
-    max: number;
-    count: number;
-    outliers: number[];
-};
+export type BoxSummaryRow = ProcessedRow & BoxSummary;

package/dist/types/plots/distribution/density/props.d.ts

@@ -1,23 +1,15 @@
 import type { BasePlotProps, PlotCoreProps } from '../../props';
 import type { AxisBasedScalesConfig } from '../../../layout/scales';
 import type { AxisBasedMarkersConfig } from '../../../markers/common';
-import type { SeriesProps, DataProps } from '../../data/common';
+import type { SeriesProps, SingleAxisDataProps } from '../../data/common';
 import type { CurveAwarePlotStylesConfig } from '../../../layout/styles';
 import type { AreaStyle } from '../../styling';
-import type { AxisChannelName, ChannelAccessors } from '../../../layout/mapping';
-/** Flat rows estimated along one axis: `x` for a vertical curve, or `y` alone for a horizontal one. */
-type DensityDataProps<TRow extends Record<string, unknown>> = Omit<DataProps<TRow>, AxisChannelName> & ((Required<Pick<ChannelAccessors<TRow>, 'x'>> & {
-    y?: never;
-}) | (Required<Pick<ChannelAccessors<TRow>, 'y'>> & {
-    x?: never;
-}));
 /** `styles` of `DensityPlot`: the curve of the estimate, and the mark that draws it. */
 export type DensityPlotStylesConfig = CurveAwarePlotStylesConfig & {
     /** The mark drawing each estimate: a filled `'area'` or a `'line'`. Defaults to `'area'`. */
     mark?: 'area' | 'line';
 };
 /** `DensityPlot`'s public props. */
-export type DensityPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DensityDataProps<TData>, TData, DensityPlotStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export type DensityPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | SingleAxisDataProps<TData>, TData, DensityPlotStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
 /** What `DensityPlot`'s core draws from. */
-export type DensityPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DensityDataProps<TData>, TData, DensityPlotStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
-export {};
+export type DensityPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | SingleAxisDataProps<TData>, TData, DensityPlotStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;

package/dist/types/plots/distribution/density/state.d.ts

@@ -1,6 +1,6 @@
 import type { AreaStyle } from '../../styling';
-import type { AxisPlotState, AxisPlotCtx } from '../../../phases';
+import type { AxisPlotState, AxisPlotEnv } from '../../../phases';
 /** DensityPlot's pipeline state: the shared axis-based state, with no extras of its own. */
 export type DensityPlotState<TData extends Record<string, unknown>> = AxisPlotState<TData, AreaStyle>;
 /** The environment every DensityPlot phase reads from, alongside the growing state. */
-export type DensityPlotCtx = AxisPlotCtx;
+export type DensityPlotEnv = AxisPlotEnv;

package/dist/types/plots/distribution/histogram/props.d.ts

@@ -1,18 +1,23 @@
+import type { KindRowContext } from '../../../layout/context';
 import type { BasePlotProps, PlotCoreProps } from '../../props';
 import type { AxisBasedScalesConfig } from '../../../layout/scales';
 import type { AxisBasedMarkersConfig } from '../../../markers/common';
-import type { SeriesProps, DataProps } from '../../data/common';
+import type { SeriesProps, SingleAxisDataProps } from '../../data/common';
 import type { AxisBasedStylesConfig } from '../../../layout/styles';
 import type { AreaStyle } from '../../styling';
-import type { AxisChannelName, ChannelAccessors } from '../../../layout/mapping';
-/** Flat rows binned on one axis: `x` for vertical bars, or `y` alone for horizontal ones. A bin's count is its length. */
-type HistogramDataProps<TRow extends Record<string, unknown>> = Omit<DataProps<TRow>, AxisChannelName> & ((Required<Pick<ChannelAccessors<TRow>, 'x'>> & {
-    y?: never;
-}) | (Required<Pick<ChannelAccessors<TRow>, 'y'>> & {
-    x?: never;
-}));
+/**
+ * What a `HistogramPlot` knows of a bin, which its tooltip's and value labels' `format`, its hover and
+ * `usePlot().contextOf` read: its `count` (also its `value`) and the edges it spans.
+ */
+export type HistogramRowContext = KindRowContext<{
+    /** How many values fall in the bin. */
+    count: number;
+    /** The bin's lower edge. */
+    from: number;
+    /** The bin's upper edge. */
+    to: number;
+}>;
 /** `HistogramPlot`'s public props. */
-export type HistogramPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | HistogramDataProps<TData>, TData, AxisBasedStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export type HistogramPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | SingleAxisDataProps<TData>, TData, AxisBasedStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>, undefined, HistogramRowContext>;
 /** What `HistogramPlot`'s core draws from. */
-export type HistogramPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | HistogramDataProps<TData>, TData, AxisBasedStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
-export {};
+export type HistogramPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | SingleAxisDataProps<TData>, TData, AxisBasedStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;

package/dist/types/plots/distribution/histogram/state.d.ts

@@ -1,6 +1,6 @@
 import type { AreaStyle } from '../../styling';
-import type { AxisPlotState, AxisPlotCtx } from '../../../phases';
+import type { AxisPlotState, AxisPlotEnv } from '../../../phases';
 /** HistogramPlot's pipeline state: the shared axis-based state, with no extras of its own. */
 export type HistogramPlotState<TData extends Record<string, unknown>> = AxisPlotState<TData, AreaStyle>;
 /** The environment every HistogramPlot phase reads from, alongside the growing state. */
-export type HistogramPlotCtx = AxisPlotCtx;
+export type HistogramPlotEnv = AxisPlotEnv;

package/dist/types/plots/distribution/pyramid/props.d.ts

@@ -1,10 +1,10 @@
 import type { BasePlotProps, PlotCoreProps } from '../../props';
 import type { AxisBasedScalesConfig } from '../../../layout/scales';
 import type { AxisBasedMarkersConfig } from '../../../markers/common';
-import type { SeriesProps, DataProps } from '../../data/common';
+import type { SeriesProps, DualAxisDataProps } from '../../data/common';
 import type { GapsAwarePlotStylesConfig } from '../../../layout/styles';
 import type { BarSegmentStyle } from '../../segments/common';
 /** `PyramidPlot`'s public props. */
-export type PyramidPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DataProps<TData>, TData, GapsAwarePlotStylesConfig<BarSegmentStyle>, BarSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export type PyramidPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DualAxisDataProps<TData>, TData, GapsAwarePlotStylesConfig<BarSegmentStyle>, BarSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
 /** What `PyramidPlot`'s core draws from. */
-export type PyramidPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DataProps<TData>, TData, GapsAwarePlotStylesConfig<BarSegmentStyle>, BarSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export type PyramidPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DualAxisDataProps<TData>, TData, GapsAwarePlotStylesConfig<BarSegmentStyle>, BarSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;

package/dist/types/plots/distribution/pyramid/state.d.ts

@@ -1,6 +1,6 @@
 import type { Series } from '../../data/common';
 import type { BarSegmentStyle } from '../../segments/common';
-import type { AxisPlotState, AxisPlotCtx } from '../../../phases';
+import type { AxisPlotState, AxisPlotEnv } from '../../../phases';
 export type PyramidSide = 'left' | 'right';
 /** A resolved series tagged with which side of the shared zero baseline it renders on. */
 export type PyramidSeries<TData extends Record<string, unknown>> = Series<TData> & {
@@ -13,4 +13,4 @@ export type PyramidSeries<TData extends Record<string, unknown>> = Series<TData>
  */
 export type PyramidPlotState<TData extends Record<string, unknown>> = AxisPlotState<TData, BarSegmentStyle, PyramidSeries<TData>>;
 /** The environment every PyramidPlot phase reads from, alongside the growing state. */
-export type PyramidPlotCtx = AxisPlotCtx;
+export type PyramidPlotEnv = AxisPlotEnv;

package/dist/types/plots/distribution/violin/props.d.ts

@@ -1,7 +1,8 @@
+import type { BoxRowContext } from '../box/props';
 import type { BasePlotProps, PlotCoreProps } from '../../props';
 import type { AxisBasedScalesConfig } from '../../../layout/scales';
 import type { AxisBasedMarkersConfig } from '../../../markers/common';
-import type { SeriesProps, DataProps } from '../../data/common';
+import type { SeriesProps, DualAxisDataProps } from '../../data/common';
 import type { AxisBasedStylesConfig } from '../../../layout/styles';
 import type { AreaStyle } from '../../styling';
 import type { DensityKernel } from '../../../transforms/density';
@@ -18,6 +19,6 @@ export type ViolinPlotStylesConfig = AxisBasedStylesConfig & {
     box?: boolean | number;
 };
 /** `ViolinPlot`'s public props. */
-export type ViolinPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DataProps<TData>, TData, ViolinPlotStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export type ViolinPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DualAxisDataProps<TData>, TData, ViolinPlotStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>, undefined, BoxRowContext>;
 /** What `ViolinPlot`'s core draws from. */
-export type ViolinPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DataProps<TData>, TData, ViolinPlotStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export type ViolinPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DualAxisDataProps<TData>, TData, ViolinPlotStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;

package/dist/types/plots/distribution/violin/state.d.ts

@@ -1,6 +1,6 @@
 import type { AreaStyle } from '../../styling';
-import type { AxisPlotState, AxisPlotCtx } from '../../../phases';
+import type { AxisPlotState, AxisPlotEnv } from '../../../phases';
 /** ViolinPlot's pipeline state: the shared axis-based state, with no extras of its own. */
 export type ViolinPlotState<TData extends Record<string, unknown>> = AxisPlotState<TData, AreaStyle>;
 /** The environment every ViolinPlot phase reads from, alongside the growing state. */
-export type ViolinPlotCtx = AxisPlotCtx;
+export type ViolinPlotEnv = AxisPlotEnv;

package/dist/types/plots/evolution/area/props.d.ts

@@ -1,10 +1,10 @@
 import type { BasePlotProps, PlotCoreProps } from '../../props';
 import type { AxisBasedScalesConfig } from '../../../layout/scales';
 import type { AxisBasedMarkersConfig } from '../../../markers/common';
-import type { SeriesProps, DataProps } from '../../data/common';
+import type { SeriesProps, DualAxisDataProps } from '../../data/common';
 import type { AxisBasedStylesConfig } from '../../../layout/styles';
 import type { AreaStyle } from '../../styling';
 /** `AreaPlot`'s public props. */
-export type AreaPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DataProps<TData>, TData, AxisBasedStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export type AreaPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DualAxisDataProps<TData>, TData, AxisBasedStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
 /** What `AreaPlot`'s core draws from. */
-export type AreaPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DataProps<TData>, TData, AxisBasedStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export type AreaPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DualAxisDataProps<TData>, TData, AxisBasedStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;

package/dist/types/plots/evolution/area/state.d.ts

@@ -1,6 +1,6 @@
 import type { AreaStyle } from '../../styling';
-import type { AxisPlotState, AxisPlotCtx } from '../../../phases';
+import type { AxisPlotState, AxisPlotEnv } from '../../../phases';
 /** AreaPlot's pipeline state: the shared axis-based state, with no extras of its own. */
 export type AreaPlotState<TData extends Record<string, unknown>> = AxisPlotState<TData, AreaStyle>;
 /** The environment every AreaPlot phase reads from, alongside the growing state. */
-export type AreaPlotCtx = AxisPlotCtx;
+export type AreaPlotEnv = AxisPlotEnv;

package/dist/types/plots/evolution/line/props.d.ts

@@ -1,10 +1,10 @@
 import type { BasePlotProps, PlotCoreProps } from '../../props';
 import type { AxisBasedScalesConfig } from '../../../layout/scales';
 import type { AxisBasedMarkersConfig } from '../../../markers/common';
-import type { SeriesProps, DataProps } from '../../data/common';
+import type { SeriesProps, DualAxisDataProps } from '../../data/common';
 import type { CurveAwarePlotStylesConfig, GapsAwarePlotStylesConfig } from '../../../layout/styles';
 import type { LineSegmentStyle } from '../../segments/common';
 /** `LinePlot`'s public props. */
-export type LinePlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DataProps<TData>, TData, GapsAwarePlotStylesConfig<LineSegmentStyle> & CurveAwarePlotStylesConfig, LineSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export type LinePlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DualAxisDataProps<TData>, TData, GapsAwarePlotStylesConfig<LineSegmentStyle> & CurveAwarePlotStylesConfig, LineSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
 /** What `LinePlot`'s core draws from. */
-export type LinePlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DataProps<TData>, TData, GapsAwarePlotStylesConfig<LineSegmentStyle> & CurveAwarePlotStylesConfig, LineSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export type LinePlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DualAxisDataProps<TData>, TData, GapsAwarePlotStylesConfig<LineSegmentStyle> & CurveAwarePlotStylesConfig, LineSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;

package/dist/types/plots/evolution/line/state.d.ts

@@ -1,9 +1,9 @@
 import type { GapsConfig } from '../../gaps';
 import type { LineSegmentStyle } from '../../segments/common';
-import type { AxisPlotState, AxisPlotCtx } from '../../../phases';
+import type { AxisPlotState, AxisPlotEnv } from '../../../phases';
 /** LinePlot's pipeline state: the shared axis-based state plus its gaps. */
 export type LinePlotState<TData extends Record<string, unknown>> = AxisPlotState<TData, LineSegmentStyle> & {
     gaps?: GapsConfig<LineSegmentStyle>;
 };
 /** The environment every LinePlot phase reads from, alongside the growing state. */
-export type LinePlotCtx = AxisPlotCtx;
+export type LinePlotEnv = AxisPlotEnv;

package/dist/types/plots/evolution/slope/state.d.ts

@@ -1,5 +1,5 @@
-import type { LinePlotState, LinePlotCtx } from '../line/state';
+import type { LinePlotState, LinePlotEnv } from '../line/state';
 /** SlopePlot's pipeline state: a LinePlot's. */
 export type SlopePlotState<TData extends Record<string, unknown>> = LinePlotState<TData>;
 /** The environment every SlopePlot phase reads from, alongside the growing state. */
-export type SlopePlotCtx = LinePlotCtx;
+export type SlopePlotEnv = LinePlotEnv;

package/dist/types/plots/evolution/sparkline/state.d.ts

@@ -1,5 +1,5 @@
-import type { LinePlotState, LinePlotCtx } from '../line/state';
+import type { LinePlotState, LinePlotEnv } from '../line/state';
 /** SparklinePlot's pipeline state: a LinePlot's. */
 export type SparklinePlotState<TData extends Record<string, unknown>> = LinePlotState<TData>;
 /** The environment every SparklinePlot phase reads from, alongside the growing state. */
-export type SparklinePlotCtx = LinePlotCtx;
+export type SparklinePlotEnv = LinePlotEnv;

package/dist/types/plots/map/geo/state.d.ts

@@ -78,7 +78,7 @@ export type GeoPlotState<TProps extends Record<string, unknown>> = {
     hoverRows?: TaggedGeoFeature<TProps>[];
 };
 /** The environment every GeoPlot phase reads from, alongside the growing state. */
-export type GeoPlotCtx<TProps extends Record<string, unknown>> = {
+export type GeoPlotEnv<TProps extends Record<string, unknown>> = {
     cfg: PlotStylesConfig;
     range: GeoRangeFilter | null | undefined;
     fill?: string;