@fundar/data-chart-telling 1.16.0 → 1.17.0

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

@@ -1,9 +1,9 @@
-import type { FontStyle, StrokeStyle } from '../../plots/styling';
+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 { TextAnchor } from '../../plots/constants';
+import type { LabelAnchor, TextAnchor } from '../../plots/constants';
 import type { NumberDisplay } from '../../layout/numbers';
 /**
  * Spreads labels that would overlap apart vertically, all reaching out to one
@@ -24,7 +24,35 @@ export type TextDeclutterConfig = {
     /** The connectors' stroke. Unset opacity follows each label's own `fillOpacity`. */
     connector?: StrokeStyle;
 };
-/** A text label per row (svelteplot's `Text`), usable on any plot kind. */
+/** Where a row's `x1`, `x2`, `y1` and `y2` are: a field of the rows, the symbol a transform keyed it by, or a function of the row. */
+type FitChannel = string | symbol | ((d: any) => unknown);
+/**
+ * What a label is fitted to: the rectangle its row spans, from `x1` to `x2` along the x axis and from `y1` to `y2`
+ * along the y - a tile of a `treemap` transform, say. A label too big for it is written smaller, down to
+ * `minFontSize`; at that size, broken into as many lines as the box holds and cut short with an ellipsis; and
+ * when almost none of it would show, as its `fallback`. A label with no room for even that is left out.
+ */
+export type TextFitConfig = {
+    /** The edges of a box of your own. A marker that draws a shape for each label gives its own, and these are left out. */
+    x1?: FitChannel;
+    x2?: FitChannel;
+    y1?: FitChannel;
+    y2?: FitChannel;
+    /** Pixels left free inside each edge of the box. Defaults to the configuration's `text.label.padding`, `4`. */
+    padding?: number;
+    /** The smallest size a label is written at, in px. Defaults to the configuration's `text.label.minFontSize`, `8`. */
+    minFontSize?: number;
+    /** The fewest letters worth writing when a text is cut short; under them the `fallback` is written. Defaults to the configuration's `text.label.minLetters`, `3`. */
+    minLetters?: number;
+    /** What to write when the text does not fit, cut short or not - a value alone, say; a number is written as the marker's `decimals` and the rest ask. */
+    fallback?: string | number | ((d: any) => string | number);
+};
+/** The text styles that can be a function of the row. */
+type TextRowStyleKey = 'fill' | 'stroke' | 'strokeWidth' | 'fontWeight' | 'fontStyle';
+/** The text styles that can be a function of the row. */
+type TextRowStyle = Pick<FontStyle, TextRowStyleKey> & {
+    fillOpacity?: number;
+};
 export type TextMarkerConfig = CommonMarkerConfigWithRowOffset<{
     type: 'text';
     /**
@@ -33,15 +61,17 @@ export type TextMarkerConfig = CommonMarkerConfigWithRowOffset<{
      * `decimals`, `prefix`, `suffix` and `signDisplay`, over the configuration's `numbers`.
      */
     text: string | number | ((d: any) => string | number);
-    styles?: FontStyle;
+    /**
+     * How the labels are drawn. `fill`, `fillOpacity`, `stroke`, `strokeWidth`, `fontWeight` and `fontStyle` can each be a function of the row;
+     * the rest place and measure the labels, so they are the same for all of them.
+     */
+    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);
-    /** Per-row fill, over `styles.fill`. */
-    fill?: string | ((d: any) => string | undefined);
-    /** Per-row fill opacity. */
-    fillOpacity?: number | ((d: any) => number | undefined);
     /** Spreads overlapping labels apart - see {@link TextDeclutterConfig}. `true` takes every default. */
     declutter?: boolean | TextDeclutterConfig;
+    /** Writes each label to fit its box - see {@link TextFitConfig}. `true` takes every default. */
+    fit?: boolean | TextFitConfig;
     /**
      * Flips each label to the other side of its point (or nudges a centred one
      * back in) where its text would cross the plot's edge. `styles.textAnchor`/
@@ -51,16 +81,28 @@ export type TextMarkerConfig = CommonMarkerConfigWithRowOffset<{
     /** 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;
     /** 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?: 'top' | 'bottom' | 'left' | 'right' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'middle';
+    frameAnchor?: LabelAnchor;
     /** Grows the plot's margins, on every side the author left open, so the labels fit. */
     fitMargins?: boolean;
     /** Reports how far the rendered labels reach past the plot's content box, in pixels, on each side. */
-    onOverflow?: (overflow: Margins) => void;
-    /** Fired when the pointer enters a row's label. */
-    onPointerEnter?: (d: any) => void;
-    /** Fired when the pointer leaves a row's label. */
-    onPointerLeave?: (d: any) => void;
+    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 = {
     /** Vertical shift (px) clearing its neighbours and the content box's edges. */

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

@@ -3,8 +3,9 @@ import type { AxisValue } from '../../layout/mapping';
 import type { StatisticConfig } from '../../layout/statistics';
 import type { MarkerTransform } from '../../transforms';
 import type { MarkLegend } from '../../layout/legend';
+import type { CommonMarkerEvents } from './commonMarkerEvents';
 /** Props every marker kind shares: rows, grouping, series scope, position, offset, statistics, transforms. */
-export type CommonMarkerConfig = {
+export type CommonMarkerConfig = CommonMarkerEvents & {
     data?: Record<string, unknown>[];
     grouping?: string | ((d: any) => unknown);
     series?: string;
@@ -27,4 +28,6 @@ export type CommonMarkerConfig = {
     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;
 };

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

@@ -1,6 +1,5 @@
 import type { CommonMarkerConfig } from './commonMarkerConfig';
-/** Common props plus the fill and opacity channels. */
+/** Common props plus the opacity channel. */
 export type CommonMarkerConfigWithArea = CommonMarkerConfig & {
-    fill?: (d: any) => string;
     opacity?: string | ((d: any) => unknown);
 };

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

@@ -0,0 +1,10 @@
+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;
+};

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

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

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

@@ -0,0 +1,17 @@
+/** The events a mark can be given a handler for, as svelteplot's own marks name them. */
+export declare const MARK_EVENTS: readonly ["onclick", "ondblclick", "oncontextmenu", "onpointerdown", "onpointerup", "onpointerenter", "onpointerleave", "onpointermove", "onmouseenter", "onmouseleave"];
+/** The name of an event a mark takes a handler for. */
+export type MarkEventName = (typeof MARK_EVENTS)[number];
+/**
+ * A handler of an event on one of a mark's shapes: the event, the row the shape draws and
+ * that row's index - as svelteplot's marks call it.
+ */
+export type MarkEventHandler = (event: Event, row: any, index: number) => void;
+/**
+ * Handlers a marker passes on to the shapes svelteplot draws for it. svelteplot documents these props on every
+ * mark (`BaseMarkProps`), and every marker hands them on; svelteplot's code wires them up on some marks only
+ * today (`Rect`, `Bar`, `Cell`, `Area`, `Arrow`, `Dot`, `Trail`, `Vector`, `Geo`, `Line`, `Link`,
+ * `DelaunayLink` and `Voronoi`), so on the others they do nothing yet - they will, whenever svelteplot's code
+ * catches up.
+ */
+export type CommonMarkerEvents = Partial<Record<MarkEventName, MarkEventHandler>>;

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

@@ -0,0 +1,13 @@
+/** The events a mark can be given a handler for, as svelteplot's own marks name them. */
+export const MARK_EVENTS = [
+    'onclick',
+    'ondblclick',
+    'oncontextmenu',
+    'onpointerdown',
+    'onpointerup',
+    'onpointerenter',
+    'onpointerleave',
+    'onpointermove',
+    'onmouseenter',
+    'onmouseleave'
+];

package/dist/types/markers/geo/contour.d.ts

@@ -1,10 +1,11 @@
+import type { CommonMarkerEvents } from '../channels/commonMarkerEvents';
 import type { Accessor } from '../../plots/data/common';
 /**
  * Marching-squares contours from a scalar field (svelteplot's `Contour`).
  * Pass `data` with `x`/`y`/`value` to interpolate samples, or omit `data` and
  * pass `value` as an `(x, y) => number` sampler.
  */
-export type GeoContourMarkerConfig<TRow extends Record<string, unknown> = Record<string, unknown>> = {
+export type GeoContourMarkerConfig<TRow extends Record<string, unknown> = Record<string, unknown>> = CommonMarkerEvents & {
     type: 'contour';
     data?: TRow[];
     x?: Accessor<TRow, number>;

package/dist/types/markers/geo/graticule.d.ts

@@ -1,6 +1,7 @@
+import type { CommonMarkerEvents } from '../channels/commonMarkerEvents';
 import type { StrokeStyle } from '../../plots/styling';
 /** Longitude and latitude gridlines (svelteplot's `Graticule`). */
-export type GeoGraticuleMarkerConfig = {
+export type GeoGraticuleMarkerConfig = CommonMarkerEvents & {
     type: 'graticule';
     step?: number;
     stepX?: number;

package/dist/types/markers/geo/link.d.ts

@@ -1,7 +1,8 @@
+import type { CommonMarkerEvents } from '../channels/commonMarkerEvents';
 import type { Accessor } from '../../plots/data/common';
 import type { StrokeStyle } from '../../plots/styling';
 /** Lines between point pairs: `curve: 'auto'` traces great-circle arcs, `'linear'` joins their projected positions with a straight line. */
-export type GeoLinkMarkerConfig<TRow extends Record<string, unknown> = Record<string, unknown>> = {
+export type GeoLinkMarkerConfig<TRow extends Record<string, unknown> = Record<string, unknown>> = CommonMarkerEvents & {
     type: 'link';
     data: TRow[];
     x1: Accessor<TRow, number>;

package/dist/types/markers/geo/sphere.d.ts

@@ -1,6 +1,7 @@
+import type { CommonMarkerEvents } from '../channels/commonMarkerEvents';
 import type { StrokeStyle } from '../../plots/styling';
 /** The outer globe outline (svelteplot's `Sphere`), for orthographic-type projections. */
-export type GeoSphereMarkerConfig = {
+export type GeoSphereMarkerConfig = CommonMarkerEvents & {
     type: 'sphere';
     styles?: StrokeStyle & {
         fill?: string;

package/dist/types/markers/geo/vector.d.ts

@@ -1,6 +1,7 @@
+import type { CommonMarkerEvents } from '../channels/commonMarkerEvents';
 import type { Accessor } from '../../plots/data/common';
 /** Arrows or spikes at points (svelteplot's `Vector`). */
-export type GeoVectorMarkerConfig<TRow extends Record<string, unknown> = Record<string, unknown>> = {
+export type GeoVectorMarkerConfig<TRow extends Record<string, unknown> = Record<string, unknown>> = CommonMarkerEvents & {
     type: 'vector';
     data: TRow[];
     x: Accessor<TRow, number>;

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

@@ -24,6 +24,11 @@ export type DataStageOptions<TState, TCtx> = {
     orderSeries?: (series: Series<any>[], state: TState) => Series<any>[];
     /** The order colors are assigned in. Defaults to the series' own order. */
     colorOrder?: (series: Series<any>[]) => Series<any>[];
+    /**
+     * Whether the kind draws the levels of its `grouping` itself (a treemap's nesting): its series are then
+     * the outermost level's values, not every level's together.
+     */
+    nested?: boolean;
     /** The plot's own extra "data" output, once the shared one is in place. */
     extend?: (state: TState, ctx: TCtx) => TState;
 };

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

@@ -35,6 +35,8 @@ export type HoverStageOptions<TState, TCtx = unknown> = {
     hitAreas?: (state: TState, hover: HoverConfig<any>, ctx: TCtx) => {
         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;
 };

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

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/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;
@@ -49,6 +54,12 @@ export type TransformsStageState = {
 export type TransformsStageOptions<TState extends TransformsStageState, TCtx> = {
     /** The transforms to run. Defaults to the plot's own `transforms`. */
     transforms?: (state: TState, ctx: TCtx) => 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

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/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/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,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';
 /** `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>>;
 /** 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/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/histogram/props.d.ts

@@ -1,18 +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, 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;
-}));
 /** `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>>;
 /** 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/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/violin/props.d.ts

@@ -1,7 +1,7 @@
 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 +18,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>>;
 /** 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/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/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/part-of-a-whole/treemap/props.d.ts

@@ -0,0 +1,19 @@
+import type { BasePlotProps, PlotCoreProps } from '../../props';
+import type { AxisBasedScalesConfig } from '../../../layout/scales';
+import type { AxisBasedMarkersConfig } from '../../../markers/common';
+import type { NonAxisDataProps } from '../../data/common';
+import type { AxisBasedStylesConfig } from '../../../layout/styles';
+import type { TooltipContext } from '../../../layout/tooltip';
+import type { BarSegmentStyle } from '../../segments/common';
+/** What a `TreemapPlot` knows of a hovered tile beyond its row, the third argument of `tooltip.format`. */
+export type TreemapTooltipContext = TooltipContext & {
+    /** The tile's part of the whole, from `0` to `100`, worked out from the values in whatever unit they are. */
+    share: number;
+};
+/**
+ * `TreemapPlot`'s public props: flat rows, a tile each, on no axes. `value` is a tile's area, and `grouping` what
+ * the tiles nest by (`'sector.branch'`, outermost first), whose outermost level colors them.
+ */
+export type TreemapPlotProps<TData extends Record<string, unknown>> = BasePlotProps<NonAxisDataProps<TData, 'value'>, TData, AxisBasedStylesConfig, BarSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>, undefined, TreemapTooltipContext>;
+/** What `TreemapPlot`'s core draws from. */
+export type TreemapPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<NonAxisDataProps<TData, 'value'>, TData, AxisBasedStylesConfig, BarSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;