@fundar/data-chart-telling 0.0.63 → 1.0.0

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

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

@@ -0,0 +1,20 @@
+import type { PositionChannels } from './common';
+/**
+ * An amount to shift by: a number in data units, or a duration on a time axis
+ * - `'1 month'`, `'-2 weeks'`, `'+1 day'`.
+ */
+export type ShiftAmount = number | string;
+/**
+ * `shiftX` as a marker transform: moves every row's `x` by `by`. Given one
+ * amount per channel (`{ x1: '-1 week', x2: '+1 week' }`), it also widens a
+ * point into an interval, each channel taken from `x` when the marker has none of its own.
+ */
+export type ShiftXTransform = {
+    type: 'shiftX';
+    by: ShiftAmount | Partial<Record<'x' | 'x1' | 'x2', ShiftAmount>>;
+} & PositionChannels;
+/** `shiftY` - see {@link ShiftXTransform}, on the `y` channels. */
+export type ShiftYTransform = {
+    type: 'shiftY';
+    by: ShiftAmount | Partial<Record<'y' | 'y1' | 'y2', ShiftAmount>>;
+} & PositionChannels;

package/dist/types/transforms/shift.js

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

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

@@ -0,0 +1,31 @@
+import type { PositionChannels, TransformChannel } from './common';
+/**
+ * What to sort by: a field key or a per-row function (sorted ascending), a
+ * comparator of two rows, or another channel by name, with its order.
+ */
+export type SortBy = TransformChannel | ((a: any, b: any) => number) | {
+    channel: string;
+    order?: 'ascending' | 'descending';
+};
+/**
+ * `sort` as a marker transform: reorders the rows. Order matters wherever rows
+ * are drawn in sequence: the path a `line` takes, which `dot` lands on top.
+ */
+export type SortTransform = {
+    type: 'sort';
+    sort: SortBy;
+    /** Reverses the sorted order. */
+    reverse?: boolean;
+} & PositionChannels;
+/** The keys `sort` reads as channels: every position channel, and `sort` itself. */
+export declare const SORT_CHANNEL_KEYS: Record<keyof PositionChannels | 'sort', true>;
+/** `shuffle` as a marker transform: puts the rows in a random order, the same one for the same `seed`. */
+export type ShuffleTransform = {
+    type: 'shuffle';
+    /** Seeds the order; a fixed seed is used when unset. */
+    seed?: number;
+} & PositionChannels;
+/** `reverse` as a marker transform: puts the rows in reverse order. */
+export type ReverseTransform = {
+    type: 'reverse';
+} & PositionChannels;

package/dist/types/transforms/sort.js

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