@fundar/data-chart-telling 0.0.64 → 1.0.0

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

@@ -1,44 +1,42 @@
-import type { HoverPoint, HoverStrategy, TooltipOptions } from '../layout/tooltip';
+import type { Pipeline } from '../../phases/Pipeline';
+import type { Snippet } from 'svelte';
+import type { TooltipOptions, TooltipProp } from '../layout/tooltip';
+import type { HoverPoint, HoverStrategy } from '../layout/hover';
+import type { LegendExtension, LegendSection } from '../layout/legend';
+import type { FacetConfig } from '../layout/facet';
+import type { GridPlacement } from '../layout/grid';
+import type { TimelineConfig } from '../layout/timeline';
 import type { Segment } from './segments/config';
 import type { AxisBasedScalesConfig } from '../layout/scales';
 import type { GeoScalesConfig } from '../layout/coordinates';
-/** The `styles` prop accepted by every plot kind — its own
+import type { StatisticConfig } from '../layout/statistics';
+import type { MarkerTransform } from '../transforms';
+/** The `styles` prop accepted by every plot kind - its own
  * styles shape ({@link AxisBasedStylesConfig}, `GeoStylesConfig`, …). */
 export type StylesConfig<TStyles extends object> = TStyles;
-/** The `markers` prop accepted by every plot kind — a list of that kind's own marker union. */
+/** The `markers` prop accepted by every plot kind - a list of that kind's own marker union. */
 export type MarkersConfig<TMarker> = TMarker[];
 /**
- * The `segments` prop accepted by every plot kind — series name (or
- * `'default'` for all series) to a list of {@link Segment}s. Within a
- * series, catch-all segments (no `areas`) evaluate first as a baseline;
- * area-specific segments merge on top and win on conflict.
+ * The `segments` prop - series name (or `'default'`) to its {@link Segment}s.
+ * Area-specific segments win over catch-all ones.
  */
 export type SegmentsConfig<TStyle> = Record<string, Segment<TStyle>[]>;
-/**
- * Partial margin override — unset sides fall back to the theme (itself
- * `'auto'` by default). `'auto'` fits the side to its rendered content; a
- * number pins it exactly.
- */
+/** One side of a box. */
+export type MarginSide = 'top' | 'right' | 'bottom' | 'left';
+/** Margin overrides per side: a number pins it, `'auto'` fits it to its content. Unset sides use the theme's. */
 export type MarginConfig = Partial<{
     top: number | 'auto';
     right: number | 'auto';
     bottom: number | 'auto';
     left: number | 'auto';
 }>;
-/**
- * The `tooltip` prop a plot actually receives — the resolved form of the
- * author-facing {@link TooltipOptions}. `format`/`sync` become required;
- * `facetId` identifies the originating facet (`''` when not faceted).
- * Presence of this object is what turns hovering on.
- */
-export type TooltipConfig<TRow extends Record<string, unknown>> = Omit<TooltipOptions<TRow>, 'format' | 'sync'> & {
-    format: (row: TRow) => string;
+/** The tooltip a plot's core draws from: {@link TooltipOptions} with `sync` resolved. Without `format`, the core uses its own default. */
+export type TooltipConfig<TRow extends Record<string, unknown>> = Omit<TooltipOptions<TRow>, 'sync'> & {
     sync: boolean;
-    facetId: string;
 };
 /** How a pointer event resolves to a candidate point: `'nearest'` (closest within a distance threshold) or `'contains'` (whichever candidate's own rendered shape contains the cursor). */
 export type PointMatchingStrategy = 'nearest' | 'contains';
-/** `BasePlotLayout`'s single `hover` prop — every plot kind's own resolved hover/tooltip wiring. */
+/** `BasePlotLayout`'s single `hover` prop - every plot kind's own resolved hover/tooltip wiring. */
 export type HoverConfig<TRow extends Record<string, unknown>> = {
     /** Whether the pointer/hover/tooltip machinery should mount at all. */
     active: boolean;
@@ -50,28 +48,113 @@ export type HoverConfig<TRow extends Record<string, unknown>> = {
     strategy?: HoverStrategy;
     /** Resolved sync flag for the *local* hover store (ignored once a shared store is in scope). */
     sync?: boolean;
-    tooltip?: TooltipConfig<TRow>;
-    /** When it returns `true`, that pointer event is treated as a leave instead of a move — lets a nested layout opt part of the plot out of hover matching. */
+    tooltip?: TooltipConfig<TRow> & {
+        format: (row: TRow) => string;
+    };
+    /** When it returns `true`, that pointer event is treated as a leave instead of a move - lets a nested layout opt part of the plot out of hover matching. */
     exclude?: (e: PointerEvent) => boolean;
-    /** How to resolve a pointer event to a candidate point — see {@link PointMatchingStrategy}. Defaults to `'nearest'`. */
+    /** How to resolve a pointer event to a candidate point - see {@link PointMatchingStrategy}. Defaults to `'nearest'`. */
     pointMatching?: PointMatchingStrategy;
     /** Forces the crosshair rule(s) a `hover` marker draws off entirely, overriding whatever `strategy` implies. */
     crosshair?: boolean;
 };
+/** The `scales` prop of any plot kind. */
+export type ScalesConfig<TData = Record<string, unknown>> = AxisBasedScalesConfig<TData> | GeoScalesConfig;
 /**
- * The `scales` prop accepted by every plot kind — either flavor of scale
- * config a plot kind can have. Each concrete `Plot.svelte` narrows
- * `BasePlotProps`'s `TScales` to exactly the one that applies to it.
+ * A block a plot's chrome draws, `plot` for the plot itself, `timeline` for
+ * its timeline when that's a player bar, or `divider` for a line between two
+ * blocks, styled by the configuration's `divider`.
  */
-export type ScalesConfig<TData = Record<string, unknown>> = AxisBasedScalesConfig<TData> | GeoScalesConfig;
+export type PlotChromeItem = 'title' | 'subtitle' | 'header' | 'legend' | 'plot' | 'caption' | 'footer' | 'timeline' | 'divider';
+/**
+ * Two or three blocks drawn side by side in one row of the chrome, written as
+ * `'(plot, timeline)'`. The `plot` takes the width the others leave, and the
+ * others take as much as they need; a row without a `plot` shares its width
+ * among its blocks, none of them stretching.
+ */
+export type PlotChromeRow<TItem extends string = Exclude<PlotChromeItem, 'divider'>> = `(${TItem}, ${TItem})` | `(${TItem}, ${TItem}, ${TItem})`;
+/** One entry of a chrome `order`: a block, or a row of blocks. */
+export type PlotChromeEntry = PlotChromeItem | PlotChromeRow;
+/**
+ * What's drawn around a figure, as `Figure` and `FigureChrome` read it: every block
+ * optional, `header` drawn instead of `title`/`subtitle` and `footer` instead
+ * of `caption`. `order` lists the blocks top to bottom (by default, the
+ * configuration's `chrome.order`); one left out isn't drawn, except `plot`, which then
+ * goes last. Any number of `divider`s may sit in it, each drawn only between
+ * two drawn blocks.
+ */
+export type PlotChromeConfig = {
+    title?: string;
+    subtitle?: string;
+    caption?: string;
+    header?: Snippet;
+    footer?: Snippet;
+    /**
+     * The figure's legend: unset or `true`, the one its plots read as - their
+     * series, scales, and the segments and markers that name themselves; `false`,
+     * none; a list of sections, exactly those; `{ items, sections }`, the
+     * automatic one with those added, and `{ series, color, opacity, size,
+     * symbol }`, with the section of each channel adjusted (see {@link LegendExtension}).
+     */
+    legend?: LegendSection[] | LegendExtension | boolean;
+    order?: PlotChromeEntry[];
+};
+/**
+ * One way to fill part of the chrome, and the `order` items it allows. A block
+ * that's passed may still be `undefined` at runtime: it's then just not drawn.
+ */
+type ChromeBlock<TProps, TItem extends PlotChromeItem> = {
+    props: TProps;
+    item: TItem;
+};
+type HeadingBlock = ChromeBlock<{
+    header: Snippet | undefined;
+    title?: never;
+    subtitle?: never;
+}, 'header'> | ChromeBlock<{
+    header?: never;
+    title: string | undefined;
+    subtitle: string | undefined;
+}, 'title' | 'subtitle'> | ChromeBlock<{
+    header?: never;
+    title: string | undefined;
+    subtitle?: never;
+}, 'title'> | ChromeBlock<{
+    header?: never;
+    title?: never;
+    subtitle: string | undefined;
+}, 'subtitle'> | ChromeBlock<{
+    header?: never;
+    title?: never;
+    subtitle?: never;
+}, never>;
+/** The legend is always there to place: unset, a figure reads one off what its plots draw. */
+type LegendBlock = ChromeBlock<{
+    legend?: LegendSection[] | LegendExtension | boolean | undefined;
+}, 'legend'>;
+type ClosingBlock = ChromeBlock<{
+    footer: Snippet | undefined;
+    caption?: never;
+}, 'footer'> | ChromeBlock<{
+    footer?: never;
+    caption: string | undefined;
+}, 'caption'> | ChromeBlock<{
+    footer?: never;
+    caption?: never;
+}, never>;
+/** Every combination of the three parts, each with an `order` of only the blocks it fills, plus `plot` and dividers. */
+type ChromeCombination<THeading, TLegend, TClosing> = THeading extends ChromeBlock<infer HP, infer HI> ? TLegend extends ChromeBlock<infer LP, infer LI> ? TClosing extends ChromeBlock<infer CP, infer CI> ? HP & LP & CP & {
+    order?: (HI | LI | CI | 'plot' | 'timeline' | 'divider' | PlotChromeRow<HI | LI | CI | 'plot' | 'timeline'>)[];
+} : never : never : never;
 /**
- * The shared prop bag every plot component accepts, parameterized over
- * everything that varies by plot kind: `TDataContract` is its own data
- * shape, `TRow` is what `tooltip` resolves against, and the rest are its
- * own segment/style/marker/scale/coordinate-system shapes. `TCoordinates`
- * defaults to `undefined` — only `GeoPlot` instantiates it.
+ * What's drawn around a plot: accepted by every plot kind and by
+ * `PlotComposer`. `header` replaces `title`/`subtitle` and `footer`
+ * replaces `caption`, so each excludes the other. `order` lists the blocks
+ * top to bottom, out of the ones set here plus `plot`, `timeline` and `divider`; see {@link PlotChromeConfig}.
  */
-export type BasePlotProps<TDataContract, TRow extends Record<string, unknown>, TStyles extends object, TSegmentStyle extends object, TMarker, TScales extends ScalesConfig<TRow>, TCoordinates = undefined> = TDataContract & {
+export type PlotChromeProps = ChromeCombination<HeadingBlock, LegendBlock, ClosingBlock>;
+/** The props every plot kind shares between its core and its public component. */
+type PlotCommonProps<TStyles extends object, TSegmentStyle extends object, TMarker, TScales, TCoordinates> = {
     width: number;
     height: number;
     styles?: StylesConfig<TStyles>;
@@ -80,5 +163,30 @@ export type BasePlotProps<TDataContract, TRow extends Record<string, unknown>, T
     scales?: TScales;
     coordinates?: TCoordinates;
     margins?: MarginConfig;
+    statistics?: StatisticConfig[];
+    transforms?: MarkerTransform[];
+};
+/** The props a plot kind's core draws from. `TCoordinates` is only set by `GeoPlot`. */
+export type PlotCoreProps<TDataContract, TRow extends Record<string, unknown>, TStyles extends object, TSegmentStyle extends object, TMarker, TScales extends ScalesConfig<TRow>, TCoordinates = undefined> = TDataContract & PlotCommonProps<TStyles, TSegmentStyle, TMarker, TScales, TCoordinates> & {
     tooltip?: TooltipConfig<TRow>;
+    /** One facet panel's part of a run of the data phases over every panel: the core then runs only the phases after them. */
+    panelState?: object;
+    /** The kind's pipeline, built once by its plot: the core runs it over its own props. */
+    pipeline?: Pipeline<any, any>;
+};
+/**
+ * A figure's box - a plot's or a `PlotComposer`'s: its own `width` and
+ * `height`, or, drawn straight inside a `PlotComposer`, the cell it takes
+ * there (an `area`, or an `inset` floating over it), whose size it draws at.
+ */
+export type FigureBoxProps = GridPlacement & {
+    width?: number;
+    height?: number;
+};
+/** A plot component's public props: its core props, chrome, `timeline`, `facet` and an author-facing `tooltip`. */
+export type BasePlotProps<TDataContract, TRow extends Record<string, unknown>, TStyles extends object, TSegmentStyle extends object, TMarker, TScales extends ScalesConfig<TRow>, TCoordinates = undefined> = TDataContract & Omit<PlotCommonProps<TStyles, TSegmentStyle, TMarker, TScales, TCoordinates>, 'width' | 'height'> & FigureBoxProps & PlotChromeProps & {
+    tooltip?: TooltipProp<TRow>;
+    timeline?: TimelineConfig<TRow>;
+    facet?: FacetConfig<TRow>;
 };
+export {};

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

@@ -0,0 +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 { 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>>;
+/** 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>>;

package/dist/types/plots/pyramid/props.js

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

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

@@ -0,0 +1,16 @@
+import type { Series } from '../data/common';
+import type { BarSegmentStyle } from '../segments/common';
+import type { AxisPlotState, AxisPlotCtx } 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> & {
+    side: PyramidSide;
+};
+/**
+ * PyramidPlot's pipeline state: the shared axis-based state with its own series
+ * and row shapes. Its `x`/`y` are the visual axes, as on every plot: the one
+ * holding categories decides whether its sides run left/right or bottom/top.
+ */
+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;

package/dist/types/plots/pyramid/state.js

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

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

@@ -0,0 +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 { 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>>;
+/** 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>>;

package/dist/types/plots/scatter/props.js

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

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

@@ -0,0 +1,6 @@
+import type { ScatterSegmentStyle } from '../segments/common';
+import type { AxisPlotState, AxisPlotCtx } 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;

package/dist/types/plots/scatter/state.js

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

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

@@ -10,7 +10,7 @@ export type BarSegmentStyle = AreaStyle;
 export type CellSegmentStyle = AreaStyle;
 /** Per-segment styling for a scatter point cloud. */
 export type ScatterSegmentStyle = DotStyle;
-/** Per-feature styling override for `GeoPlot` — the geo analog of `CellSegmentStyle`. */
+/** Per-feature styling override for `GeoPlot` - the geo analog of `CellSegmentStyle`. */
 export type GeoSegmentStyle = {
     fill?: string;
     fillOpacity?: number;

package/dist/types/plots/segments/config.d.ts

@@ -1,6 +1,8 @@
-import type { AxisValue } from '../../layout/scales';
+import type { ChannelScalesConfig } from '../../layout/scales';
+import type { AxisValue } from '../../layout/mapping';
 import type { Series } from '../data/common';
 import type { LineSegmentStyle } from './common';
+import type { MarkLegend } from '../../layout/legend';
 /** A half-open interval on one axis. Both bounds are inclusive; omit either to leave that end open. */
 export type Range = {
     from?: AxisValue;
@@ -21,7 +23,7 @@ export type Area = {
 /**
  * One styled rule for a plot. A data point (or cell) is styled when it falls
  * inside **any** of the listed `areas`. Omitting `areas` (or passing an empty
- * array) makes the segment a catch-all that matches every data point — useful
+ * array) makes the segment a catch-all that matches every data point - useful
  * as a baseline style. `TStyle` is the per-mark shape ({@link LineSegmentStyle},
  * {@link BarSegmentStyle}, {@link CellSegmentStyle}, …).
  *
@@ -31,16 +33,20 @@ export type Area = {
  */
 export type Segment<TStyle> = {
     areas?: Area[];
-    style?: TStyle;
+    scales?: ChannelScalesConfig;
+    styles?: TStyle;
+    /** Names the segment on its plot's automatic legend - see {@link MarkLegend}. */
+    legend?: MarkLegend;
 };
-/** One contiguous, styled slice of a series' data — ready to draw as its own mark. */
+/** One contiguous, styled slice of a series' data - ready to draw as its own mark. */
 export type VisualSegment<T extends Record<string, unknown>, TStyle = LineSegmentStyle> = {
     data: T[];
-    style: TStyle;
+    scales?: ChannelScalesConfig;
+    styles: TStyle;
 };
 /**
  * A series split into its styled visual segments. `S` is the full series
- * type Series<T> — its row type is read off `S['data']`
+ * type Series<T> - its row type is read off `S['data']`
  * rather than taken as a separate parameter, since TypeScript can't reliably
  * infer a type parameter that only appears inside another parameter's
  * constraint.

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

@@ -1,5 +1,5 @@
 import type { FontWeight, FontStyleKeyword, TextAnchor, LineAnchor, LineStyle, LineCap, LineJoin, SymbolType } from './constants';
-/** Text/label styling for any text mark — a marker's label, an annotation, a value label. */
+/** Text/label styling for any text mark - a marker's label, an annotation, a value label. */
 export type FontStyle = {
     fill?: string;
     fontSize?: number;
@@ -17,7 +17,7 @@ export type FontStyle = {
     class?: string;
     textClass?: string;
 };
-/** Stroke styling for any line-ish mark — a line, a rule, a marker's connector. */
+/** Stroke styling for any line-ish mark - a line, a rule, a marker's connector. */
 export type StrokeStyle = {
     stroke?: string;
     strokeWidth?: number;
@@ -27,10 +27,10 @@ export type StrokeStyle = {
     strokeLinejoin?: LineJoin;
 };
 /**
- * Dot styling for any point mark — a line's endpoint dots, a marker's dot.
+ * Dot styling for any point mark - a line's endpoint dots, a marker's dot.
  * Carries its own `dotStroke*` fields rather than nesting a {@link StrokeStyle},
  * because a dot's outline is a distinct style from the stroke of the line (or
- * other mark) it sits next to — e.g. a `LineSegmentStyle` styles its
+ * other mark) it sits next to - e.g. a `LineSegmentStyle` styles its
  * line's stroke and its dots' outline independently.
  */
 export type DotStyle = {
@@ -43,7 +43,7 @@ export type DotStyle = {
     dotStrokeOpacity?: number;
     dotStrokeDasharray?: string | LineStyle;
 };
-/** Styling for a 2D area mark — a bar segment, a heatmap cell, a geo feature highlight. */
+/** Styling for a 2D area mark - a bar segment, a heatmap cell, a geo feature highlight. */
 export type AreaStyle = {
     fill?: string;
     fillOpacity?: number;

package/dist/types/transforms/bin.d.ts

@@ -0,0 +1,84 @@
+import type { TransformChannel, TransformReducer } from './common';
+type BinReducer = TransformReducer;
+/** Channels both bin transforms read besides their binned one; `z` splits each bin by a group. */
+type SharedBinChannels = {
+    data?: Record<string, unknown>[];
+    z?: TransformChannel;
+    insetLeft?: number;
+    insetRight?: number;
+    insetTop?: number;
+    insetBottom?: number;
+};
+/** Channels `binX` reads: its binned `x`, plus the shared ones. */
+export type BinXChannels = SharedBinChannels & {
+    x?: TransformChannel;
+};
+/** Channels `binY` reads: its binned `y`, plus the shared ones. */
+export type BinYChannels = SharedBinChannels & {
+    y?: TransformChannel;
+};
+/**
+ * The keys of {@link BinXChannels}, at runtime. Typed as a record over the
+ * type's own keys, so a key added to or removed from the type fails to compile here.
+ */
+export declare const BIN_X_CHANNEL_KEYS: Record<keyof BinXChannels, true>;
+/** The keys of {@link BinYChannels}, at runtime - see {@link BIN_X_CHANNEL_KEYS}. */
+export declare const BIN_Y_CHANNEL_KEYS: Record<keyof BinYChannels, true>;
+/** Channels the 2D `bin` reads: both binned axes, plus the shared ones. */
+export type Bin2DChannels = SharedBinChannels & {
+    x?: TransformChannel;
+    y?: TransformChannel;
+};
+/** The keys of {@link Bin2DChannels}, at runtime - see {@link BIN_X_CHANNEL_KEYS}. */
+export declare const BIN_2D_CHANNEL_KEYS: Record<keyof Bin2DChannels, true>;
+/** Options both bin transforms take, flat next to the channels - same names as svelteplot's. */
+type BinOptions = {
+    /** Explicit thresholds, a count, or a named generator (`auto`, `scott`, `sturges`, `freedman-diaconis`). */
+    thresholds?: 'auto' | 'scott' | 'sturges' | 'freedman-diaconis' | number | number[];
+    /** Bin width as an interval (a number or a named one like `'day'`); takes over from `thresholds`. */
+    interval?: number | string;
+    /** The domain the bins cover. */
+    domain?: [number, number];
+    /** Accumulates the bins: `1` from the start, `-1` from the end. */
+    cumulative?: false | 1 | -1;
+    /** Reverses the output rows. */
+    reverse?: boolean;
+    /** Reducers for the bin's other output channels. */
+    fill?: BinReducer;
+    stroke?: BinReducer;
+    r?: BinReducer;
+    opacity?: BinReducer;
+    fillOpacity?: BinReducer;
+    strokeOpacity?: BinReducer;
+};
+/**
+ * `binX` as a marker transform: its own props, flat, exactly as svelteplot's
+ * `binX` takes them. Svelteplot names the binned channel `x` and its value
+ * output `y` (a reducer such as `'count'`). Both live in one flat object, so
+ * here `x` is the input and `y` is always the reducer - grouping goes through
+ * `z`, which a marker fills from its `grouping`.
+ */
+export type BinXTransform = {
+    type: 'binX';
+    /** The bins' value - a reducer such as `'count'`. */
+    y?: BinReducer;
+} & BinXChannels & BinOptions;
+/**
+ * `binY` as a marker transform - see {@link BinXTransform}; here `y` is the
+ * binned input and `x` is the reducer.
+ */
+export type BinYTransform = {
+    type: 'binY';
+    /** The bins' value - a reducer such as `'count'`. */
+    x?: BinReducer;
+} & BinYChannels & BinOptions;
+/**
+ * `bin` as a marker transform: bins on `x` and `y` at once, so each output row
+ * is one cell of a 2D grid with its `x1`/`x2`/`y1`/`y2` edges. Its value goes to
+ * one of the other channels - `fill: 'count'` colors each cell by its row count,
+ * `r: 'count'` sizes a dot by it.
+ */
+export type Bin2DTransform = {
+    type: 'bin';
+} & Bin2DChannels & BinOptions;
+export {};

package/dist/types/transforms/bin.js

@@ -0,0 +1,28 @@
+/**
+ * The keys of {@link BinXChannels}, at runtime. Typed as a record over the
+ * type's own keys, so a key added to or removed from the type fails to compile here.
+ */
+export const BIN_X_CHANNEL_KEYS = {
+    data: true,
+    x: true,
+    z: true,
+    insetLeft: true,
+    insetRight: true,
+    insetTop: true,
+    insetBottom: true
+};
+/** The keys of {@link BinYChannels}, at runtime - see {@link BIN_X_CHANNEL_KEYS}. */
+export const BIN_Y_CHANNEL_KEYS = {
+    data: true,
+    y: true,
+    z: true,
+    insetLeft: true,
+    insetRight: true,
+    insetTop: true,
+    insetBottom: true
+};
+/** The keys of {@link Bin2DChannels}, at runtime - see {@link BIN_X_CHANNEL_KEYS}. */
+export const BIN_2D_CHANNEL_KEYS = {
+    ...BIN_X_CHANNEL_KEYS,
+    y: true
+};

package/dist/types/transforms/bollinger.d.ts

@@ -0,0 +1,21 @@
+import type { PositionChannels } from './common';
+/** Options both Bollinger transforms take - same names as svelteplot's. */
+type BollingerOptions = {
+    /** The moving window's size, in rows; defaults to 20. */
+    n?: number;
+    /** The band's radius, in standard deviations; defaults to 2. */
+    k?: number;
+};
+/**
+ * `bollingerY` as a marker transform: a moving mean of `y` over `n` rows with a
+ * band `k` standard deviations around it - the mean as `y`, the band as
+ * `y1`/`y2`. A `line` draws the mean, an `area` the band. Runs per `z` group.
+ */
+export type BollingerYTransform = {
+    type: 'bollingerY';
+} & PositionChannels & BollingerOptions;
+/** `bollingerX` - see {@link BollingerYTransform}, on `x`. */
+export type BollingerXTransform = {
+    type: 'bollingerX';
+} & PositionChannels & BollingerOptions;
+export {};

package/dist/types/transforms/bollinger.js

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

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

@@ -0,0 +1,29 @@
+import type { AxisValue } from '../layout/mapping';
+/**
+ * A channel a transform reads: a field key, or a per-row function - the same
+ * shape every marker's own `x`/`y` takes.
+ */
+export type TransformChannel = string | ((d: any) => AxisValue | unknown);
+/**
+ * A reducer a grouping transform (bin, group) runs over each group's rows:
+ * svelteplot's own name (`count`, `sum`, `mean`, `p25`, …) or a function of the rows.
+ */
+export type TransformReducer = string | ((group: any[]) => unknown);
+/** The position channels most transforms read, by svelteplot's own names; `z` splits the rows into groups. */
+export type PositionChannels = {
+    data?: Record<string, unknown>[];
+    x?: TransformChannel;
+    y?: TransformChannel;
+    x1?: TransformChannel;
+    x2?: TransformChannel;
+    y1?: TransformChannel;
+    y2?: TransformChannel;
+    z?: TransformChannel;
+    fill?: TransformChannel;
+    stroke?: TransformChannel;
+};
+/**
+ * The keys of {@link PositionChannels}, at runtime. Typed as a record over the
+ * type's own keys, so a key added to or removed from the type fails to compile here.
+ */
+export declare const POSITION_CHANNEL_KEYS: Record<keyof PositionChannels, true>;

package/dist/types/transforms/common.js

@@ -0,0 +1,16 @@
+/**
+ * The keys of {@link PositionChannels}, at runtime. Typed as a record over the
+ * type's own keys, so a key added to or removed from the type fails to compile here.
+ */
+export const POSITION_CHANNEL_KEYS = {
+    data: true,
+    x: true,
+    y: true,
+    x1: true,
+    x2: true,
+    y1: true,
+    y2: true,
+    z: true,
+    fill: true,
+    stroke: true
+};

package/dist/types/transforms/density.d.ts

@@ -0,0 +1,45 @@
+import type { TransformChannel } from './common';
+/** Kernel shapes svelteplot's own density transforms support. */
+export type DensityKernel = 'uniform' | 'triangular' | 'epanechnikov' | 'quartic' | 'triweight' | 'gaussian' | 'cosine';
+/** Channels both density transforms read; `weight` gives each row its share of the estimate. */
+type DensityChannels = {
+    data?: Record<string, unknown>[];
+    x?: TransformChannel;
+    y?: TransformChannel;
+    z?: TransformChannel;
+    fill?: TransformChannel;
+    stroke?: TransformChannel;
+    weight?: (d: any) => number;
+};
+/** The keys of the density transforms' channels, at runtime. */
+export declare const DENSITY_CHANNEL_KEYS: Record<keyof DensityChannels, true>;
+/** Options both density transforms take, flat next to the channels - same names as svelteplot's. */
+type DensityOptions = {
+    /** The kernel's shape, or a kernel function of `u`; defaults to `epanechnikov`. */
+    kernel?: DensityKernel | ((u: number) => number);
+    /** Kernel bandwidth in data units, or a function of the sorted values; defaults to Silverman's rule. */
+    bandwidth?: number | ((values: number[]) => number);
+    /** The spacing of the points the estimate is sampled at; defaults to a fifth of the bandwidth. */
+    interval?: number | string;
+    /** Keeps the curve within the data's own extent, instead of letting it fade out past it. */
+    trim?: boolean;
+    /** Accumulates the estimate into a CDF: `1` from the start, `-1` from the end. */
+    cumulative?: false | 1 | -1;
+};
+/**
+ * `densityX` as a marker transform: a 1D kernel density estimate over the `x`
+ * values. Replaces the rows with points along `x`, and their density goes to
+ * `y` (or `channel`: `y1`/`y2` for a band). One curve per `z` group.
+ */
+export type DensityXTransform = {
+    type: 'densityX';
+    /** The channel the density goes to. */
+    channel?: 'y' | 'y1' | 'y2';
+} & DensityChannels & DensityOptions;
+/** `densityY` - see {@link DensityXTransform}, estimating over `y` with the density on `x`. */
+export type DensityYTransform = {
+    type: 'densityY';
+    /** The channel the density goes to. */
+    channel?: 'x' | 'x1' | 'x2';
+} & DensityChannels & DensityOptions;
+export {};

package/dist/types/transforms/density.js

@@ -0,0 +1,10 @@
+/** The keys of the density transforms' channels, at runtime. */
+export const DENSITY_CHANNEL_KEYS = {
+    data: true,
+    x: true,
+    y: true,
+    z: true,
+    fill: true,
+    stroke: true,
+    weight: true
+};

package/dist/types/transforms/filter.d.ts

@@ -0,0 +1,12 @@
+import type { PositionChannels, TransformChannel } from './common';
+/**
+ * `filter` as a marker transform: keeps only the rows `filter` holds for -
+ * a per-row test, or a field key whose value is truthy. Unlike filtering the
+ * marker's `data` beforehand, it composes with the transforms around it.
+ */
+export type FilterTransform = {
+    type: 'filter';
+    filter: TransformChannel;
+} & PositionChannels;
+/** The keys `filter` reads as channels: every position channel, and `filter` itself. */
+export declare const FILTER_CHANNEL_KEYS: Record<keyof PositionChannels | 'filter', true>;