@fundar/data-chart-telling 0.0.64 → 1.0.0

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

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

@@ -0,0 +1,64 @@
+import { type PositionChannels, type TransformChannel } from './common';
+/** Channels both stack transforms read, by svelteplot's own names. */
+export type StackChannels = PositionChannels;
+/** The keys of {@link StackChannels}, at runtime. */
+export declare const STACK_CHANNEL_KEYS: Record<keyof PositionChannels, true>;
+/** Options both stack transforms take, flat next to the channels - same names as svelteplot's. */
+type StackOptions = {
+    /** Offset method; unset keeps svelteplot's zero baseline. */
+    offset?: 'none' | 'wiggle' | 'center' | 'normalize' | 'diverging' | null;
+    /** Series order; unset keeps the input order. */
+    order?: 'none' | 'appearance' | 'inside-out' | 'sum' | null;
+    /** Reverses the stacking order. */
+    reverse?: boolean;
+};
+/**
+ * `stackY` as a marker transform: its own props, flat, exactly as svelteplot's
+ * `stackY` takes them. `type` picks the transform; everything else is that
+ * transform's own input.
+ */
+export type StackYTransform = {
+    type: 'stackY';
+} & StackChannels & StackOptions;
+/** `stackX` as a marker transform - see {@link StackYTransform}. */
+export type StackXTransform = {
+    type: 'stackX';
+} & StackChannels & StackOptions;
+/**
+ * Channels the mosaic stacks read: the outer category, the inner category, and
+ * each cell's `value`. svelteplot reads all three straight off the rows, so
+ * they're field keys, not functions.
+ */
+export type StackMosaicChannels = {
+    data?: Record<string, unknown>[];
+    x?: string;
+    y?: string;
+    value?: string;
+    fill?: TransformChannel;
+    stroke?: TransformChannel;
+};
+/** The keys of {@link StackMosaicChannels}, at runtime - see {@link POSITION_CHANNEL_KEYS}. */
+export declare const STACK_MOSAIC_CHANNEL_KEYS: Record<keyof StackMosaicChannels, true>;
+/**
+ * Options the mosaic stacks take. svelteplot nests them as `{ x: { percent }, y: { percent } }`,
+ * which would clash with the flat `x`/`y` channels, so they're flattened here.
+ */
+type StackMosaicOptions = {
+    /** Puts `x` in fractions of the whole (0-1) instead of the values' own sums. */
+    percentX?: boolean;
+    /** Puts `y` in fractions of the whole (0-1) instead of the values' own sums. */
+    percentY?: boolean;
+};
+/**
+ * `stackMosaicX` as a marker transform: a mosaic (Marimekko) layout. Each `x`
+ * category gets a column as wide as its total `value`, split along `y` by its
+ * inner categories. Produces `x1`/`x2`/`y1`/`y2` for a `rect` marker.
+ */
+export type StackMosaicXTransform = {
+    type: 'stackMosaicX';
+} & StackMosaicChannels & StackMosaicOptions;
+/** `stackMosaicY` - see {@link StackMosaicXTransform}, with the outer categories along `y`. */
+export type StackMosaicYTransform = {
+    type: 'stackMosaicY';
+} & StackMosaicChannels & StackMosaicOptions;
+export {};

package/dist/types/transforms/stack.js

@@ -0,0 +1,12 @@
+import { POSITION_CHANNEL_KEYS } from './common';
+/** The keys of {@link StackChannels}, at runtime. */
+export const STACK_CHANNEL_KEYS = POSITION_CHANNEL_KEYS;
+/** The keys of {@link StackMosaicChannels}, at runtime - see {@link POSITION_CHANNEL_KEYS}. */
+export const STACK_MOSAIC_CHANNEL_KEYS = {
+    data: true,
+    x: true,
+    y: true,
+    value: true,
+    fill: true,
+    stroke: true
+};

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

@@ -0,0 +1,29 @@
+import type { PositionChannels } from './common';
+/** The reducers svelteplot's window transforms take by name. */
+export type WindowReducer = 'count' | 'deviation' | 'difference' | 'first' | 'last' | 'max' | 'mean' | 'median' | 'min' | 'mode' | 'ratio' | 'sum' | 'variance';
+/** Options both window transforms take, flat next to the channels - same names as svelteplot's. */
+type WindowOptions = {
+    /** The window's size, in rows (or in `interval`s, when one is set). */
+    k: number;
+    /** What each window reduces to; defaults to `mean`. */
+    reduce?: WindowReducer | ((values: any[]) => unknown);
+    /** Where each row sits in its window; defaults to `middle`. */
+    anchor?: 'start' | 'middle' | 'end';
+    /** Leaves out a window with fewer than `k` values (or than the number given), instead of reducing what it has. */
+    strict?: boolean | number;
+    /** Measures the window along the other axis in this interval (`'day'`, `7`, …) instead of in rows. */
+    interval?: number | string;
+};
+/**
+ * `windowY` as a marker transform: replaces each row's `y` (and `y1`/`y2`) with
+ * a reduction of the `k` rows around it - a moving average by default. Runs
+ * per `z` group, in row order.
+ */
+export type WindowYTransform = {
+    type: 'windowY';
+} & PositionChannels & WindowOptions;
+/** `windowX` - see {@link WindowYTransform}, on the `x` channels. */
+export type WindowXTransform = {
+    type: 'windowX';
+} & PositionChannels & WindowOptions;
+export {};

package/dist/types/transforms/window.js

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

package/dist/utils/ContinuousDomain.d.ts

@@ -0,0 +1,12 @@
+import type { LegendRange } from '../types/layout/legend';
+/** The domain a continuous color ramp is drawn over. */
+export declare class ContinuousDomain {
+    /**
+     * The `[min, max]` a continuous color ramp spans: the author's numeric
+     * `domain`, or the extent of `values` - reaching zero with `fromZero`.
+     * `null` when there is neither.
+     */
+    static build(authorDomain: readonly unknown[] | undefined, values: number[], fromZero?: boolean): [number, number] | null;
+    /** The domain a ramp is drawn over: the legend's narrowed range in `'rescale'` mode, `domain` otherwise. */
+    static ramp(domain: [number, number], range: Pick<LegendRange, 'mode' | 'min' | 'max'> | null | undefined): [number, number];
+}

package/dist/utils/ContinuousDomain.js

@@ -0,0 +1,19 @@
+/** The domain a continuous color ramp is drawn over. */
+export class ContinuousDomain {
+    /**
+     * The `[min, max]` a continuous color ramp spans: the author's numeric
+     * `domain`, or the extent of `values` - reaching zero with `fromZero`.
+     * `null` when there is neither.
+     */
+    static build(authorDomain, values, fromZero = false) {
+        if (authorDomain && typeof authorDomain[0] === 'number')
+            return authorDomain;
+        if (!values.length)
+            return null;
+        return [Math.min(...values, ...(fromZero ? [0] : [])), Math.max(...values)];
+    }
+    /** The domain a ramp is drawn over: the legend's narrowed range in `'rescale'` mode, `domain` otherwise. */
+    static ramp(domain, range) {
+        return range && range.mode === 'rescale' ? [range.min, range.max] : domain;
+    }
+}

package/dist/utils/Interpolation.d.ts

@@ -0,0 +1,26 @@
+import type { EasingName, EasingFn } from '../types/misc/easing';
+import type { TimeValue, TimelineInterpolation } from '../types/layout/timeline';
+import type { AxisValue } from '../types/layout/mapping';
+import type { Accessor } from '../types/plots/data/common';
+/** Easing curves, and the tweens a timeline draws between its steps. */
+export declare class Interpolation {
+    static readonly EASINGS: Record<EasingName, EasingFn>;
+    static buildEasing(easing?: EasingName | EasingFn): EasingFn;
+    /**
+     * Tweens one key-group's sorted rows at a continuous position `x`: every
+     * passed row plus the synthetic row between the two surrounding ones.
+     */
+    static tweenSeries<TRow>({ rows, x, getTime, getValue, create, segmentEasing }: {
+        rows: TRow[];
+        x: TimeValue;
+        getTime: (row: TRow) => TimeValue;
+        getValue: (row: TRow) => number;
+        create: (lower: TRow, upper: TRow, x: TimeValue, value: number) => TRow;
+        segmentEasing: EasingFn;
+    }): TRow[];
+    /** `TimelineConfig.interpolate` as a full {@link TimelineInterpolation}, with the plot's `value`/`key` as defaults. */
+    static buildTimeline<TRow extends Record<string, unknown>>(interpolate: boolean | TimelineInterpolation<TRow> | undefined, defaults: {
+        value: Accessor<TRow, AxisValue>;
+        key?: Accessor<TRow, unknown>;
+    }): TimelineInterpolation<TRow> | undefined;
+}

package/dist/utils/Interpolation.js

@@ -0,0 +1,65 @@
+/** Easing curves, and the tweens a timeline draws between its steps. */
+export class Interpolation {
+    static EASINGS = {
+        linear: (t) => t,
+        quadIn: (t) => t * t,
+        quadOut: (t) => 1 - (1 - t) * (1 - t),
+        cubicIn: (t) => t * t * t,
+        cubicOut: (t) => 1 - Math.pow(1 - t, 3),
+        quartIn: (t) => t * t * t * t,
+        quartOut: (t) => 1 - Math.pow(1 - t, 4),
+        expoOut: (t) => (t === 1 ? 1 : 1 - Math.pow(2, -10 * t))
+    };
+    static buildEasing(easing) {
+        if (!easing)
+            return Interpolation.EASINGS.linear;
+        if (typeof easing === 'function')
+            return easing;
+        return Interpolation.EASINGS[easing] ?? Interpolation.EASINGS.linear;
+    }
+    /**
+     * Tweens one key-group's sorted rows at a continuous position `x`: every
+     * passed row plus the synthetic row between the two surrounding ones.
+     */
+    static tweenSeries({ rows, x, getTime, getValue, create, segmentEasing }) {
+        if (!rows.length)
+            return [];
+        const sorted = [...rows].sort((a, b) => Number(getTime(a)) - Number(getTime(b)));
+        if (x <= getTime(sorted[0]))
+            return [sorted[0]];
+        const result = [];
+        for (let i = 0; i < sorted.length - 1; i++) {
+            const d0 = sorted[i];
+            const d1 = sorted[i + 1];
+            const t0 = getTime(d0);
+            const t1 = getTime(d1);
+            if (x >= t1) {
+                result.push(d0);
+                continue;
+            }
+            if (x >= t0 && x < t1) {
+                const tRaw = (Number(x) - Number(t0)) / (Number(t1) - Number(t0));
+                const t = segmentEasing(tRaw);
+                const value = getValue(d0) + (getValue(d1) - getValue(d0)) * t;
+                result.push(d0);
+                result.push(create(d0, d1, x, value));
+                return result;
+            }
+        }
+        const last = sorted[sorted.length - 1];
+        if (x >= getTime(last))
+            result.push(last);
+        return result;
+    }
+    /** `TimelineConfig.interpolate` as a full {@link TimelineInterpolation}, with the plot's `value`/`key` as defaults. */
+    static buildTimeline(interpolate, defaults) {
+        if (!interpolate)
+            return undefined;
+        const config = interpolate === true ? {} : interpolate;
+        return {
+            ...config,
+            value: config.value ?? defaults.value,
+            key: config.key ?? defaults.key
+        };
+    }
+}

package/dist/utils/{color.d.ts → color/contrast.d.ts}

@@ -1,7 +1,3 @@
-export declare function resolveCssColor(color: string): string;
-export declare function normalize(v: number, min: number, max: number): number;
-/** Cycles through a discrete palette by series index — the default colour for an unstyled series. */
-export declare function paletteColor(index: number, palette: string[]): string;
 /** WCAG contrast ratio between two colors, from 1 (no contrast) to 21 (black on white). */
 export declare function contrastRatio(colorA: string, colorB: string): number;
 /**
@@ -11,4 +7,3 @@ export declare function contrastRatio(colorA: string, colorB: string): number;
  * `background` can't be parsed.
  */
 export declare function contrastTextColor(background: string, candidates?: string[]): string;
-export declare function makeColorScale(min: number, max: number, colorMin: string, colorMax: string): (v: number) => string;