@fundar/data-chart-telling 0.0.64 → 1.1.0

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

package/dist/types/transforms/filter.js

@@ -0,0 +1,14 @@
+/** The keys `filter` reads as channels: every position channel, and `filter` itself. */
+export const FILTER_CHANNEL_KEYS = {
+    data: true,
+    x: true,
+    y: true,
+    x1: true,
+    x2: true,
+    y1: true,
+    y2: true,
+    z: true,
+    fill: true,
+    stroke: true,
+    filter: true
+};

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

@@ -0,0 +1,70 @@
+import type { TransformChannel, TransformReducer } from './common';
+/** Channels every group transform reads: the grouped one(s), the value to reduce, and `z`. */
+type GroupChannels = {
+    data?: Record<string, unknown>[];
+    x?: TransformChannel;
+    y?: TransformChannel;
+    z?: TransformChannel;
+    /** Leaves out the rows this per-row test fails for, before grouping. */
+    filter?: TransformChannel;
+};
+/** The keys every group transform reads as channels, at runtime. */
+export declare const GROUP_CHANNEL_KEYS: Record<keyof GroupChannels, true>;
+/** Reducers for the non-positional outputs: `fill: 'count'` colors by the group's size, `r: 'sum'` sizes a dot by it. */
+type GroupStyleOutputs = {
+    fill?: TransformReducer;
+    stroke?: TransformReducer;
+    r?: TransformReducer;
+    opacity?: TransformReducer;
+    fillOpacity?: TransformReducer;
+    strokeOpacity?: TransformReducer;
+};
+/** Options every group transform takes. */
+type GroupOptions = {
+    /** Groups values by this interval (`10`, `'month'`) instead of by each distinct value. */
+    interval?: number | string;
+    /** Fields copied onto each group's row from its first source row. */
+    copy?: string[];
+};
+/**
+ * `groupX` as a marker transform: one row per distinct `x` (and per `z` group),
+ * its other channels reduced over the group's rows. The marker's `y` is the
+ * value the `y` reducer reads, so `y: 'sum'` sums each group's `y`; here `y` is
+ * always the reducer, as with a bin. `count` needs no `y` at all.
+ */
+export type GroupXTransform = {
+    type: 'groupX';
+    y?: TransformReducer;
+    y1?: TransformReducer;
+    y2?: TransformReducer;
+    /** The field the group's `x` goes under on the output rows; defaults to `x`'s own field key. */
+    xPropName?: string;
+} & Omit<GroupChannels, 'y'> & GroupStyleOutputs & GroupOptions;
+/** `groupY` - see {@link GroupXTransform}, grouping on `y` and reducing to `x`. */
+export type GroupYTransform = {
+    type: 'groupY';
+    x?: TransformReducer;
+    x1?: TransformReducer;
+    x2?: TransformReducer;
+    /** The field the group's `y` goes under on the output rows; defaults to `y`'s own field key. */
+    yPropName?: string;
+} & Omit<GroupChannels, 'x'> & GroupStyleOutputs & GroupOptions;
+/** `groupZ` - one row per `z` group, every channel a reducer: `x: 'mean', y: 'mean'` is each group's centroid. */
+export type GroupZTransform = {
+    type: 'groupZ';
+    x?: TransformReducer;
+    x1?: TransformReducer;
+    x2?: TransformReducer;
+    y?: TransformReducer;
+    y1?: TransformReducer;
+    y2?: TransformReducer;
+} & Omit<GroupChannels, 'x' | 'y'> & GroupStyleOutputs & GroupOptions;
+/**
+ * `group` as a marker transform: one row per distinct `x`-`y` pair - a grid of
+ * categories - reduced to `fill`, `r` or another style output. `r: 'count'` on
+ * a `dot` draws a bubble per pair, sized by how many rows share it.
+ */
+export type Group2DTransform = {
+    type: 'group';
+} & GroupChannels & GroupStyleOutputs & Omit<GroupOptions, 'interval'>;
+export {};

package/dist/types/transforms/group.js

@@ -0,0 +1,8 @@
+/** The keys every group transform reads as channels, at runtime. */
+export const GROUP_CHANNEL_KEYS = {
+    data: true,
+    x: true,
+    y: true,
+    z: true,
+    filter: true
+};

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

@@ -0,0 +1,36 @@
+import type { StackXTransform, StackYTransform, StackMosaicXTransform, StackMosaicYTransform } from './stack';
+import type { BinXTransform, BinYTransform, Bin2DTransform } from './bin';
+import type { DensityXTransform, DensityYTransform } from './density';
+import type { WindowXTransform, WindowYTransform } from './window';
+import type { BollingerXTransform, BollingerYTransform } from './bollinger';
+import type { NormalizeXTransform, NormalizeYTransform, NormalizeParallelXTransform, NormalizeParallelYTransform } from './normalize';
+import type { MapXTransform, MapYTransform } from './map';
+import type { IntervalXTransform, IntervalYTransform } from './interval';
+import type { JitterXTransform, JitterYTransform } from './jitter';
+import type { ShiftXTransform, ShiftYTransform } from './shift';
+import type { SortTransform, ShuffleTransform, ReverseTransform } from './sort';
+import type { FilterTransform } from './filter';
+import type { SelectTransform, SelectShorthandTransform } from './select';
+import type { GroupXTransform, GroupYTransform, GroupZTransform, Group2DTransform } from './group';
+export type { TransformChannel, TransformReducer, PositionChannels } from './common';
+export type { StackXTransform, StackYTransform, StackMosaicXTransform, StackMosaicYTransform } from './stack';
+export type { BinXTransform, BinYTransform, Bin2DTransform } from './bin';
+export type { DensityKernel, DensityXTransform, DensityYTransform } from './density';
+export type { WindowReducer, WindowXTransform, WindowYTransform } from './window';
+export type { BollingerXTransform, BollingerYTransform } from './bollinger';
+export type { NormalizeBasis, NormalizeXTransform, NormalizeYTransform, NormalizeParallelXTransform, NormalizeParallelYTransform } from './normalize';
+export type { MapMethod, MapXTransform, MapYTransform } from './map';
+export type { IntervalXTransform, IntervalYTransform } from './interval';
+export type { JitterXTransform, JitterYTransform } from './jitter';
+export type { ShiftAmount, ShiftXTransform, ShiftYTransform } from './shift';
+export type { SortBy, SortTransform, ShuffleTransform, ReverseTransform } from './sort';
+export type { FilterTransform } from './filter';
+export type { SelectBy, SelectTransform, SelectShorthandTransform } from './select';
+export type { GroupXTransform, GroupYTransform, GroupZTransform, Group2DTransform } from './group';
+/**
+ * Every svelteplot transform a marker (via `CommonMarkerConfig.transforms`) or
+ * a plot (via its `transforms` prop) can run on its rows before they're drawn.
+ * Each one is a flat object: `type` picks the transform, and the rest are its
+ * own channels and options, by svelteplot's own names.
+ */
+export type MarkerTransform = StackYTransform | StackXTransform | StackMosaicXTransform | StackMosaicYTransform | BinXTransform | BinYTransform | Bin2DTransform | DensityXTransform | DensityYTransform | WindowXTransform | WindowYTransform | BollingerXTransform | BollingerYTransform | NormalizeXTransform | NormalizeYTransform | NormalizeParallelXTransform | NormalizeParallelYTransform | MapXTransform | MapYTransform | IntervalXTransform | IntervalYTransform | JitterXTransform | JitterYTransform | ShiftXTransform | ShiftYTransform | SortTransform | ShuffleTransform | ReverseTransform | FilterTransform | SelectTransform | SelectShorthandTransform | GroupXTransform | GroupYTransform | GroupZTransform | Group2DTransform;

package/dist/types/transforms/index.js

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

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

@@ -0,0 +1,21 @@
+import type { PositionChannels } from './common';
+/** The option both interval transforms take. */
+type IntervalOptions = {
+    /** The interval each value is widened to: a number, or a named one (`'month'`, `'week'`, …). */
+    interval: number | string;
+};
+/**
+ * `intervalX` as a marker transform: widens each row's `x` into the interval
+ * around it, floored to the interval - `x1` at its start, `x2` at the next
+ * one's. A `rect` then spans each interval, like a bar on a continuous axis.
+ */
+export type IntervalXTransform = {
+    type: 'intervalX';
+} & PositionChannels & IntervalOptions;
+/** `intervalY` - see {@link IntervalXTransform}, producing `y1`/`y2`. */
+export type IntervalYTransform = {
+    type: 'intervalY';
+} & PositionChannels & IntervalOptions;
+/** The keys the interval transforms read: every position channel, and `interval`, which svelteplot reads next to them. */
+export declare const INTERVAL_CHANNEL_KEYS: Record<keyof PositionChannels | 'interval', true>;
+export {};

package/dist/types/transforms/interval.js

@@ -0,0 +1,14 @@
+/** The keys the interval transforms read: every position channel, and `interval`, which svelteplot reads next to them. */
+export const INTERVAL_CHANNEL_KEYS = {
+    data: true,
+    x: true,
+    y: true,
+    x1: true,
+    x2: true,
+    y1: true,
+    y2: true,
+    z: true,
+    fill: true,
+    stroke: true,
+    interval: true
+};

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

@@ -0,0 +1,34 @@
+import type { PositionChannels } from './common';
+/**
+ * Options both jitter transforms take. svelteplot names the distribution
+ * `type`, which here picks the transform, so it's `distribution` instead.
+ */
+type JitterOptions = {
+    /** Draws the noise from a uniform or a normal distribution; defaults to `uniform`. */
+    distribution?: 'uniform' | 'normal';
+    /** Half-width of the uniform noise, in data units (or a duration like `'3 days'`); defaults to 0.35. */
+    width?: number | string;
+    /** Standard deviation of the normal noise, in data units; defaults to 0.15. */
+    std?: number | string;
+    /**
+     * Seeds the noise, so every render draws the same offsets; a fixed seed (a
+     * different one per axis) is used when unset. Change it for a different,
+     * equally stable draw.
+     */
+    seed?: number;
+    /** Your own source of random numbers in [0, 1); takes over from `seed`. */
+    source?: () => number;
+};
+/**
+ * `jitterX` as a marker transform: nudges each row's `x` by a small random
+ * amount, so points that share a value spread out instead of hiding each other.
+ * Only numbers and dates are nudged.
+ */
+export type JitterXTransform = {
+    type: 'jitterX';
+} & PositionChannels & JitterOptions;
+/** `jitterY` - see {@link JitterXTransform}, on `y`. */
+export type JitterYTransform = {
+    type: 'jitterY';
+} & PositionChannels & JitterOptions;
+export {};

package/dist/types/transforms/jitter.js

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

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

@@ -0,0 +1,24 @@
+import type { PositionChannels } from './common';
+/**
+ * How each group's values are mapped: `cumsum` (a running total), `rank`
+ * (0, 1, 2, …), `quantile` (rank as 0-1), or a function of the group's indices
+ * and values returning the mapped values, in the same order.
+ */
+export type MapMethod = 'cumsum' | 'rank' | 'quantile' | ((index: number[], values: any[]) => any[]);
+/** The option both map transforms take. */
+type MapOptions = {
+    map: MapMethod;
+};
+/**
+ * `mapY` as a marker transform: replaces each `z` group's `y` (and `y1`/`y2`)
+ * values with a function of the whole group - unlike a per-row accessor, it
+ * sees every value at once.
+ */
+export type MapYTransform = {
+    type: 'mapY';
+} & PositionChannels & MapOptions;
+/** `mapX` - see {@link MapYTransform}, on the `x` channels. */
+export type MapXTransform = {
+    type: 'mapX';
+} & PositionChannels & MapOptions;
+export {};

package/dist/types/transforms/map.js

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

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

@@ -0,0 +1,36 @@
+import type { PositionChannels } from './common';
+/**
+ * What each group's values are divided by (or, for `deviation` and `extent`,
+ * rescaled against): a named basis, or a function of the group's indices and values.
+ */
+export type NormalizeBasis = 'first' | 'last' | 'min' | 'max' | 'mean' | 'median' | 'sum' | 'deviation' | 'extent' | ((index: number[], values: any[]) => number);
+/** The option every normalize transform takes. */
+type NormalizeOptions = {
+    /** Defaults to `first`: each group then starts at 1. */
+    basis?: NormalizeBasis;
+};
+/**
+ * `normalizeY` as a marker transform: divides each `z` group's `y` values by
+ * the group's own `basis`, so groups on different scales share one axis -
+ * `first` indexes every series to its starting value.
+ */
+export type NormalizeYTransform = {
+    type: 'normalizeY';
+} & PositionChannels & NormalizeOptions;
+/** `normalizeX` - see {@link NormalizeYTransform}, on `x`. */
+export type NormalizeXTransform = {
+    type: 'normalizeX';
+} & PositionChannels & NormalizeOptions;
+/**
+ * `normalizeParallelY` as a marker transform, for parallel coordinates: each
+ * `x` category (an axis) is normalized on its own, while `z` still keeps one
+ * line per record. With `basis: 'extent'`, every axis spans 0-1.
+ */
+export type NormalizeParallelYTransform = {
+    type: 'normalizeParallelY';
+} & PositionChannels & NormalizeOptions;
+/** `normalizeParallelX` - see {@link NormalizeParallelYTransform}, with the axes along `y`. */
+export type NormalizeParallelXTransform = {
+    type: 'normalizeParallelX';
+} & PositionChannels & NormalizeOptions;
+export {};

package/dist/types/transforms/normalize.js

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

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

@@ -0,0 +1,15 @@
+import type { PositionChannels } from './common';
+/** Which row `select` keeps per group: the first or last one, or the one with the lowest or highest value of a channel. */
+export type SelectBy = 'first' | 'last' | Partial<Record<'x' | 'y', 'min' | 'max'>>;
+/**
+ * `select` as a marker transform: keeps one row per `z` group. Handy for
+ * labelling a line's end, or marking each series' peak.
+ */
+export type SelectTransform = {
+    type: 'select';
+    select: SelectBy;
+} & PositionChannels;
+/** Shorthands for {@link SelectTransform}: `selectFirst` is `select: 'first'`, `selectMaxY` is `select: { y: 'max' }`, and so on. */
+export type SelectShorthandTransform = {
+    type: 'selectFirst' | 'selectLast' | 'selectMinX' | 'selectMaxX' | 'selectMinY' | 'selectMaxY';
+} & PositionChannels;

package/dist/types/transforms/select.js

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