@fundar/data-chart-telling 0.0.64 → 1.0.0

package/dist/phases/transforms/Transforms.js

@@ -0,0 +1,130 @@
+import { StackTransform } from './methods/StackTransform';
+import { BinTransform } from './methods/BinTransform';
+import { DensityTransform } from './methods/DensityTransform';
+import { WindowTransform } from './methods/WindowTransform';
+import { NormalizeTransform } from './methods/NormalizeTransform';
+import { PositionTransform } from './methods/PositionTransform';
+import { OrderTransform } from './methods/OrderTransform';
+import { GroupTransform } from './methods/GroupTransform';
+/** Each transform type's adapter: its channels, how it runs, and its own fixes. */
+const ADAPTERS = {
+    stackX: StackTransform.x,
+    stackY: StackTransform.y,
+    stackMosaicX: StackTransform.mosaicX,
+    stackMosaicY: StackTransform.mosaicY,
+    binX: BinTransform.x,
+    binY: BinTransform.y,
+    bin: BinTransform.grid,
+    densityX: DensityTransform.x,
+    densityY: DensityTransform.y,
+    windowX: WindowTransform.windowX,
+    windowY: WindowTransform.windowY,
+    bollingerX: WindowTransform.bollingerX,
+    bollingerY: WindowTransform.bollingerY,
+    normalizeX: NormalizeTransform.x,
+    normalizeY: NormalizeTransform.y,
+    normalizeParallelX: NormalizeTransform.parallelX,
+    normalizeParallelY: NormalizeTransform.parallelY,
+    mapX: NormalizeTransform.mapX,
+    mapY: NormalizeTransform.mapY,
+    intervalX: PositionTransform.intervalX,
+    intervalY: PositionTransform.intervalY,
+    jitterX: PositionTransform.jitterX,
+    jitterY: PositionTransform.jitterY,
+    shiftX: PositionTransform.shiftX,
+    shiftY: PositionTransform.shiftY,
+    sort: OrderTransform.sort,
+    shuffle: OrderTransform.shuffle,
+    reverse: OrderTransform.reverse,
+    filter: OrderTransform.filter,
+    select: OrderTransform.select,
+    selectFirst: OrderTransform.first,
+    selectLast: OrderTransform.last,
+    selectMinX: OrderTransform.minX,
+    selectMaxX: OrderTransform.maxX,
+    selectMinY: OrderTransform.minY,
+    selectMaxY: OrderTransform.maxY,
+    groupX: GroupTransform.x,
+    groupY: GroupTransform.y,
+    groupZ: GroupTransform.z,
+    group: GroupTransform.grid
+};
+/** Runs a marker's or a plot's transforms through svelteplot, one type's adapter at a time. */
+export class Transforms {
+    /** The channels a marker hands down to its transforms, when it has them. */
+    static INHERITED_CHANNELS = ['x', 'y', 'x1', 'x2', 'y1', 'y2'];
+    /**
+     * Runs one transform through svelteplot and returns what it produces - the
+     * transform's own output, ready to spread into the marker's props. A marker
+     * transform is one flat object, so its props are split once: the ones the
+     * transform reads as channels go first, and the rest (a stack's `offset`, a
+     * bin's `thresholds` and reducers) go second, as svelteplot's own signature
+     * takes them. An unset prop is left out, so svelteplot's own default applies.
+     *
+     * `inherited` holds the channels the marker hands down (its rows, `x`/`y`,
+     * grouping as `z`). Only the ones the transform reads are used, and the
+     * transform's own channels win over them.
+     */
+    static run(transform, inherited = {}) {
+        const adapter = ADAPTERS[transform.type];
+        const { channelKeys, outputKeys } = adapter;
+        const isOption = (key) => outputKeys?.[key] === true || channelKeys[key] !== true;
+        const props = Object.entries(transform).filter(([k, v]) => k !== 'type' && v !== undefined);
+        const readable = Object.entries(inherited).filter(([k, v]) => channelKeys[k] === true && v !== undefined);
+        const split = {
+            channels: Object.fromEntries([...readable, ...props.filter(([k]) => !isOption(k))]),
+            options: Object.fromEntries(props.filter(([k]) => isOption(k)))
+        };
+        const { channels, options } = adapter.prepare ? adapter.prepare(split) : split;
+        return adapter.run(channels, options);
+    }
+    /**
+     * Applies a marker's `transforms` in order, each one's output feeding the next.
+     * A transform reads the marker's own rows, position channels and `grouping`
+     * (its `z`) by default, falling back to the plot's rows when the marker has
+     * none. Any of those the transform sets itself wins. The output is merged onto
+     * the marker.
+     *
+     * A transform only inherits the channels it reads (its adapter's `channelKeys`),
+     * so a bin's reducer slot is never filled from the marker: a marker's `y` is not
+     * read as `binX`'s `'count'` reducer. A `z` the transform hands back becomes
+     * the marker's `grouping`, and a `fill`/`stroke` it reduces to becomes the
+     * marker's `color`, so the marker keeps drawing its groups and colors from the
+     * new rows. Once every transform has run, {@link Transforms.finish} applies each
+     * type's fix to the marker.
+     */
+    static resolve(marker, fallbackData) {
+        const own = marker;
+        if (!own.transforms?.length)
+            return marker;
+        let resolved = { ...own };
+        for (const transform of own.transforms) {
+            const inherited = {
+                data: resolved.data ?? fallbackData,
+                z: resolved.grouping,
+                ...Object.fromEntries(Transforms.INHERITED_CHANNELS.map((k) => [k, resolved[k]]))
+            };
+            const { z, fill, stroke, ...out } = Transforms.run(transform, inherited);
+            resolved = { ...resolved, ...out };
+            if (z !== undefined)
+                resolved.grouping = z;
+            const color = fill ?? stroke;
+            if (color != null && resolved.color === undefined)
+                resolved.color = color;
+        }
+        return Transforms.finish(resolved, own.transforms);
+    }
+    /**
+     * Applies each transform type's `finish` fix to a marker drawing rows those
+     * transforms produced, once per type used - for a marker built from rows that
+     * were transformed before it existed (a plot's own processed data).
+     */
+    static finish(marker, transforms) {
+        let finished = marker;
+        for (const adapter of new Set(transforms.map((t) => ADAPTERS[t.type]))) {
+            if (adapter.finish)
+                finished = adapter.finish(finished);
+        }
+        return finished;
+    }
+}

package/dist/phases/transforms/TransformsPhase.d.ts

@@ -0,0 +1,64 @@
+import type { Series } from '../../types/plots/data/common';
+import type { SegmentsConfig } from '../../types/plots/props';
+import type { VisualGroup } from '../../types/plots/segments/config';
+import type { PhaseStage, ProcessedData, ProcessedRow, TransformsStageOptions, TransformsStageState } from '../../types/phases';
+/** The field each processed row carries its series name under, for its color, legend and labels. */
+export declare const SERIES_KEY = "__series";
+/** The field each processed row carries its series id under - the transforms' `z`, so a stack or bin keeps series apart. */
+export declare const SERIES_ID_KEY = "__seriesId";
+/** The field a gap-filled row carries its interpolated value under, for the transforms to read. */
+export declare const GAP_VALUE = "__gapValue";
+/** The field a gap-filled row carries its gap kind under, so a processed copy of it keeps its fill style. */
+export declare const GAP_KIND = "__gapKind";
+/**
+ * The "transforms" phase every axis-based plot shares: runs the plot-level
+ * transforms once over every visible series' rows together, so a stack sees
+ * every series and a bin keeps each series apart (both group by series), and
+ * leaves the result in `state.processedData` for the plot's own marks. With
+ * facet panels, the transforms run once per panel's rows, so a stack never
+ * combines two panels, and every row they return keeps its panel. A gap that
+ * `styles.gaps` fills is read at its interpolated value, so it takes its place
+ * in a stack the way a real value would, and keeps its gap kind.
+ */
+export declare class TransformsPhase<TState extends TransformsStageState, TCtx = unknown> implements PhaseStage<TState, TCtx> {
+    #private;
+    readonly phase: "transforms";
+    constructor(options?: TransformsStageOptions<TState, TCtx>);
+    run: (state: TState, ctx: TCtx) => TState;
+    /**
+     * The processed rows split back into one group per visible series, each cut
+     * into its styled visual segments by `segments`, matched on the processed `x`.
+     * Each series reads its rows through its value axis: a stack's top, a bin's start.
+     */
+    static buildProcessedGroups<TStyle>(state: TransformsStageState & {
+        segments?: SegmentsConfig<TStyle>;
+    }, connect?: boolean): VisualGroup<Series<ProcessedRow>, TStyle>[];
+    /**
+     * The processed rows in their own order, split into runs of consecutive rows
+     * from the same visible series, each cut into its styled visual segments like
+     * {@link TransformsPhase.buildProcessedGroups}. Drawn in turn, the runs keep the rows' order
+     * across series, so a transform that reorders rows (`sort`, `reverse`,
+     * `shuffle`) decides which rows paint on top. Unreordered, each series is one run.
+     */
+    static buildProcessedRuns<TStyle>(state: TransformsStageState & {
+        segments?: SegmentsConfig<TStyle>;
+    }): VisualGroup<Series<ProcessedRow>, TStyle>[];
+    /**
+     * Where a processed row sits: the top of its value (`y2`, or `y` - `x2`/`x`
+     * when `valueAxis` is `x`) and, on the other axis, its own position (or the
+     * middle of its `1`-`2` span, a bin's centre).
+     */
+    static processedPosition(processed: ProcessedData, valueAxis?: 'x' | 'y'): {
+        x: (row: ProcessedRow) => unknown;
+        y: (row: ProcessedRow) => unknown;
+    };
+    /**
+     * A processed row's span along `valueAxis`: from its `1` channel (a stack's
+     * bottom) or, with none, from `baseline`, to its top. `undefined` when the
+     * row has no value there. `stacked` tells a stack from plain values.
+     */
+    static processedSpan(processed: ProcessedData, valueAxis: 'x' | 'y', baseline?: number): {
+        stacked: boolean;
+        of: (row: ProcessedRow) => [number, number] | undefined;
+    };
+}

package/dist/phases/transforms/TransformsPhase.js

@@ -0,0 +1,242 @@
+import { Transforms } from './Transforms';
+import { seriesIdOf } from '../../utils/grouping';
+import { PANEL_KEY } from '../facet/FacetPhase';
+import { resolveAccessor } from '../../plots/utils/accessors';
+import { isGapValue } from '../../plots/utils/gaps';
+import { buildGroupedSeries } from '../../plots/utils/segments';
+import { PlotAxes } from '../data/PlotAxes';
+/** The field each processed row carries its series name under, for its color, legend and labels. */
+export const SERIES_KEY = '__series';
+/** The field each processed row carries its series id under - the transforms' `z`, so a stack or bin keeps series apart. */
+export const SERIES_ID_KEY = '__seriesId';
+/** The field a gap-filled row carries its interpolated value under, for the transforms to read. */
+export const GAP_VALUE = '__gapValue';
+/** The field a gap-filled row carries its gap kind under, so a processed copy of it keeps its fill style. */
+export const GAP_KIND = '__gapKind';
+const CHANNEL_NAMES = ['x', 'y', 'x1', 'x2', 'y1', 'y2'];
+/** Props of a transform's output that are neither a channel nor an option for the mark. */
+const NOT_OPTIONS = new Set(['data', 'z', 'grouping', 'transforms', 'sort', 'filter']);
+/**
+ * The "transforms" phase every axis-based plot shares: runs the plot-level
+ * transforms once over every visible series' rows together, so a stack sees
+ * every series and a bin keeps each series apart (both group by series), and
+ * leaves the result in `state.processedData` for the plot's own marks. With
+ * facet panels, the transforms run once per panel's rows, so a stack never
+ * combines two panels, and every row they return keeps its panel. A gap that
+ * `styles.gaps` fills is read at its interpolated value, so it takes its place
+ * in a stack the way a real value would, and keeps its gap kind.
+ */
+export class TransformsPhase {
+    phase = 'transforms';
+    #options;
+    constructor(options = {}) {
+        this.#options = options;
+    }
+    run = (state, ctx) => {
+        const options = this.#options;
+        const series = (state.resolvedSeries ?? []);
+        // A gap `styles.gaps` fills carries its filled value and kind, and reads at that value.
+        const fillsOf = (s) => state.gapFillMaps?.get(seriesIdOf(s));
+        const data = series.flatMap((s) => s.data.map((row) => ({
+            ...row,
+            ...TransformsPhase.#fillTags(fillsOf(s)?.get(row)),
+            [SERIES_KEY]: s.name,
+            [SERIES_ID_KEY]: seriesIdOf(s),
+            ...(s.panel !== undefined ? { [PANEL_KEY]: s.panel } : {})
+        })));
+        const valueAxis = PlotAxes.valueOf(state);
+        const shared = {
+            x: TransformsPhase.#sharedChannel(series, 'x'),
+            y: TransformsPhase.#sharedChannel(series, 'y')
+        };
+        const own = shared[valueAxis];
+        const filled = [...(state.gapFillMaps?.values() ?? [])].some((fills) => fills.size > 0);
+        if (filled && own !== undefined) {
+            const read = resolveAccessor(own);
+            shared[valueAxis] = (row) => row[GAP_VALUE] ?? read(row);
+        }
+        const { x, y } = shared;
+        const transforms = options.transforms
+            ? options.transforms(state, ctx)
+            : (state.transforms ?? []);
+        if (!transforms.length) {
+            const channels = Object.fromEntries(Object.entries({ x, y }).filter(([, channel]) => channel !== undefined));
+            const processedData = { data, channels, options: {}, transforms };
+            return { ...state, processedData };
+        }
+        const out = TransformsPhase.#runByPanel(data, (rows) => Transforms.resolve({ data: rows, x, y, grouping: SERIES_ID_KEY, transforms }, rows));
+        const channels = {};
+        const markOptions = {};
+        for (const [key, value] of Object.entries(out)) {
+            if (CHANNEL_NAMES.includes(key)) {
+                channels[key] = value;
+            }
+            else if (!NOT_OPTIONS.has(key)) {
+                markOptions[key] = value;
+            }
+        }
+        // An aggregating transform (bin, group) keeps only its `z`, the series id: put the name back.
+        const nameById = new Map(series.map((s) => [seriesIdOf(s), s.name]));
+        const rows = out.data;
+        for (const row of rows) {
+            if (row[SERIES_KEY] === undefined && row[SERIES_ID_KEY] !== undefined) {
+                row[SERIES_KEY] = nameById.get(row[SERIES_ID_KEY]);
+            }
+        }
+        const processedData = {
+            data: rows,
+            channels,
+            options: markOptions,
+            transforms
+        };
+        return { ...state, processedData };
+    };
+    /** What a gap-filled row carries: its interpolated value and the kind of zone that filled it. */
+    static #fillTags(fill) {
+        return fill ? { [GAP_VALUE]: fill.value, [GAP_KIND]: fill.kind } : {};
+    }
+    /**
+     * The processed rows split back into one group per visible series, each cut
+     * into its styled visual segments by `segments`, matched on the processed `x`.
+     * Each series reads its rows through its value axis: a stack's top, a bin's start.
+     */
+    static buildProcessedGroups(state, connect = true) {
+        const { data } = state.processedData;
+        const series = (state.resolvedSeries ?? []).map((s) => TransformsPhase.#processedSeries(state, s, data.filter((row) => row[SERIES_ID_KEY] === seriesIdOf(s))));
+        return buildGroupedSeries(series, state.segments, connect);
+    }
+    /**
+     * The processed rows in their own order, split into runs of consecutive rows
+     * from the same visible series, each cut into its styled visual segments like
+     * {@link TransformsPhase.buildProcessedGroups}. Drawn in turn, the runs keep the rows' order
+     * across series, so a transform that reorders rows (`sort`, `reverse`,
+     * `shuffle`) decides which rows paint on top. Unreordered, each series is one run.
+     */
+    static buildProcessedRuns(state) {
+        const byId = new Map((state.resolvedSeries ?? []).map((s) => [seriesIdOf(s), s]));
+        const runs = [];
+        for (const row of state.processedData.data) {
+            const source = byId.get(row[SERIES_ID_KEY]);
+            if (!source)
+                continue;
+            const last = runs.at(-1);
+            if (last && seriesIdOf(last) === seriesIdOf(source))
+                last.data.push(row);
+            else
+                runs.push(TransformsPhase.#processedSeries(state, source, [row]));
+        }
+        return buildGroupedSeries(runs, state.segments, false);
+    }
+    /**
+     * Where a processed row sits: the top of its value (`y2`, or `y` - `x2`/`x`
+     * when `valueAxis` is `x`) and, on the other axis, its own position (or the
+     * middle of its `1`-`2` span, a bin's centre).
+     */
+    static processedPosition(processed, valueAxis = 'y') {
+        const { channels } = processed;
+        const read = (channel) => resolveAccessor(channel);
+        const along = (axis) => {
+            const own = channels[axis];
+            const from = channels[`${axis}1`];
+            const to = channels[`${axis}2`];
+            if (axis === valueAxis) {
+                const top = to ?? own;
+                return top !== undefined ? read(top) : () => undefined;
+            }
+            if (own !== undefined)
+                return read(own);
+            if (from === undefined || to === undefined)
+                return () => undefined;
+            return (row) => (Number(read(from)(row)) + Number(read(to)(row))) / 2;
+        };
+        return { x: along('x'), y: along('y') };
+    }
+    /**
+     * A processed row's span along `valueAxis`: from its `1` channel (a stack's
+     * bottom) or, with none, from `baseline`, to its top. `undefined` when the
+     * row has no value there. `stacked` tells a stack from plain values.
+     */
+    static processedSpan(processed, valueAxis, baseline = 0) {
+        const from = processed.channels[`${valueAxis}1`];
+        const stacked = from !== undefined && processed.channels[`${valueAxis}2`] !== undefined;
+        const top = TransformsPhase.processedPosition(processed, valueAxis)[valueAxis];
+        const bottom = stacked
+            ? resolveAccessor(from)
+            : () => baseline;
+        return {
+            stacked,
+            of: (row) => {
+                const end = top(row);
+                const start = bottom(row);
+                if (isGapValue(end) || isGapValue(start))
+                    return undefined;
+                const span = [Number(start), Number(end)];
+                return Number.isFinite(span[0]) && Number.isFinite(span[1]) ? span : undefined;
+            }
+        };
+    }
+    /**
+     * One series accessor shared by every series as-is, so a field key keeps
+     * feeding svelteplot's axis-title inference; a per-series function otherwise.
+     * `undefined` when no series sets the channel.
+     */
+    static #sharedChannel(series, key) {
+        const first = series[0]?.[key];
+        if (series.every((s) => s[key] === first))
+            return first;
+        const byId = new Map(series.map((s) => [seriesIdOf(s), s[key] === undefined ? undefined : resolveAccessor(s[key])]));
+        return (row) => byId.get(row[SERIES_ID_KEY])?.(row);
+    }
+    /**
+     * Runs `run` over each facet panel's rows (or over every row, without
+     * panels) and joins the results: the rows in panel order, each tagged with its
+     * panel, and the channels and options of the first run - the transforms set
+     * the same ones for every panel.
+     */
+    static #runByPanel(data, run) {
+        const panels = new Map();
+        for (const row of data) {
+            const bucket = panels.get(row[PANEL_KEY]);
+            if (bucket)
+                bucket.push(row);
+            else
+                panels.set(row[PANEL_KEY], [row]);
+        }
+        if (panels.size === 0 || (panels.size === 1 && panels.has(undefined))) {
+            return run(data);
+        }
+        let first;
+        const rows = [];
+        for (const [panel, panelRows] of panels) {
+            const out = run(panelRows);
+            first ??= out;
+            for (const row of out.data) {
+                if (panel !== undefined && row[PANEL_KEY] === undefined)
+                    row[PANEL_KEY] = panel;
+                rows.push(row);
+            }
+        }
+        return { ...first, data: rows };
+    }
+    /**
+     * One series over some of its processed rows. With no transforms it keeps its
+     * own `x`/`y`; otherwise it reads the transforms' channels - on the value axis
+     * a stack's top (`y2` as its `y`, or `x2` as its `x` on a horizontal plot), on
+     * the other a bin's start.
+     */
+    static #processedSeries(state, source, data) {
+        const { channels, transforms } = state.processedData;
+        const valueAxis = PlotAxes.valueOf(state);
+        const read = (axis) => (transforms.length
+            ? (channels[axis] ??
+                channels[`${axis}${axis === valueAxis ? 2 : 1}`])
+            : source[axis]);
+        return {
+            name: source.name,
+            ...(source.id !== undefined ? { id: source.id } : {}),
+            x: read('x'),
+            y: read('y'),
+            data
+        };
+    }
+}

package/dist/phases/transforms/methods/AnchorBar.d.ts

@@ -0,0 +1,13 @@
+import type { Row } from '../../../types/phases/transforms/adapter';
+/** The fix transforms that give a `rect` a value on one axis share. */
+export declare class AnchorBar {
+    /**
+     * A `rect` a transform gave a value on one axis, with no far edge on that axis,
+     * draws a bar from zero up to that value, the way svelteplot's `RectY`/`RectX`
+     * do. A bin's or a group's value arrives as `y` (for `binX`/`groupX`) or `x`
+     * (for `binY`/`groupY`), so the bar's far end on that axis is set here, once the
+     * transforms have run. A value with an edge already is left alone, as is a
+     * `rect` with an `interval`, which svelteplot draws itself.
+     */
+    static toZero(axis: 'x' | 'y'): (marker: Row) => Row;
+}

package/dist/phases/transforms/methods/AnchorBar.js

@@ -0,0 +1,21 @@
+/** The fix transforms that give a `rect` a value on one axis share. */
+export class AnchorBar {
+    /**
+     * A `rect` a transform gave a value on one axis, with no far edge on that axis,
+     * draws a bar from zero up to that value, the way svelteplot's `RectY`/`RectX`
+     * do. A bin's or a group's value arrives as `y` (for `binX`/`groupX`) or `x`
+     * (for `binY`/`groupY`), so the bar's far end on that axis is set here, once the
+     * transforms have run. A value with an edge already is left alone, as is a
+     * `rect` with an `interval`, which svelteplot draws itself.
+     */
+    static toZero(axis) {
+        const [near, far] = axis === 'y' ? ['y1', 'y2'] : ['x1', 'x2'];
+        return (marker) => {
+            if (marker.type !== 'rect' || marker.interval !== undefined)
+                return marker;
+            if (marker[axis] === undefined || marker[far] !== undefined)
+                return marker;
+            return { ...marker, [near]: marker[near] ?? 0, [far]: marker[axis] };
+        };
+    }
+}

package/dist/phases/transforms/methods/BinTransform.d.ts

@@ -0,0 +1,7 @@
+import type { TransformAdapter } from '../../../types/phases/transforms/adapter';
+/** svelteplot's bin transforms: along `x`, along `y`, or both. */
+export declare class BinTransform {
+    static readonly x: TransformAdapter;
+    static readonly y: TransformAdapter;
+    static readonly grid: TransformAdapter;
+}

package/dist/phases/transforms/methods/BinTransform.js

@@ -0,0 +1,48 @@
+import { bin, binX, binY } from 'svelteplot';
+import { BIN_X_CHANNEL_KEYS, BIN_Y_CHANNEL_KEYS, BIN_2D_CHANNEL_KEYS } from '../../../types/transforms/bin';
+import { AnchorBar } from './AnchorBar';
+/**
+ * A numeric `interval` makes svelteplot start and stop its bins at the data's own
+ * extremes, so the first and last bins come out cut short. Without an explicit
+ * `domain`, this snaps the domain out to the interval's grid, so every bin is the
+ * same width. Date intervals, and a `domain` the transform sets itself, are left alone.
+ */
+function alignBinToInterval(dim) {
+    return ({ channels, options }) => {
+        const { interval, domain } = options;
+        const data = channels.data;
+        if (typeof interval !== 'number' || domain !== undefined || !data) {
+            return { channels, options };
+        }
+        const binned = channels[dim];
+        const read = typeof binned === 'function'
+            ? binned
+            : (d) => (binned ? d[binned] : undefined);
+        const values = data.map((d) => Number(read(d))).filter(Number.isFinite);
+        if (!values.length)
+            return { channels, options };
+        const lo = Math.floor(Math.min(...values) / interval) * interval;
+        const hi = Math.ceil(Math.max(...values) / interval) * interval;
+        return { channels, options: { ...options, domain: [lo, hi] } };
+    };
+}
+/** svelteplot's bin transforms: along `x`, along `y`, or both. */
+export class BinTransform {
+    static x = {
+        channelKeys: BIN_X_CHANNEL_KEYS,
+        run: binX,
+        prepare: alignBinToInterval('x'),
+        finish: AnchorBar.toZero('y')
+    };
+    static y = {
+        channelKeys: BIN_Y_CHANNEL_KEYS,
+        run: binY,
+        prepare: alignBinToInterval('y'),
+        finish: AnchorBar.toZero('x')
+    };
+    // Bins on both axes: every cell already has both edges, so no bar to anchor.
+    static grid = {
+        channelKeys: BIN_2D_CHANNEL_KEYS,
+        run: bin
+    };
+}

package/dist/phases/transforms/methods/DensityTransform.d.ts

@@ -0,0 +1,6 @@
+import type { TransformAdapter } from '../../../types/phases/transforms/adapter';
+/** svelteplot's density transforms, by axis. */
+export declare class DensityTransform {
+    static readonly x: TransformAdapter;
+    static readonly y: TransformAdapter;
+}

package/dist/phases/transforms/methods/DensityTransform.js

@@ -0,0 +1,13 @@
+import { densityX, densityY } from 'svelteplot';
+import { DENSITY_CHANNEL_KEYS } from '../../../types/transforms/density';
+/** svelteplot's density transforms, by axis. */
+export class DensityTransform {
+    static x = {
+        channelKeys: DENSITY_CHANNEL_KEYS,
+        run: densityX
+    };
+    static y = {
+        channelKeys: DENSITY_CHANNEL_KEYS,
+        run: densityY
+    };
+}

package/dist/phases/transforms/methods/GroupTransform.d.ts

@@ -0,0 +1,8 @@
+import type { TransformAdapter } from '../../../types/phases/transforms/adapter';
+/** svelteplot's group transforms: along `x`, along `y`, by `z`, or both axes. */
+export declare class GroupTransform {
+    static readonly x: TransformAdapter;
+    static readonly y: TransformAdapter;
+    static readonly z: TransformAdapter;
+    static readonly grid: TransformAdapter;
+}

package/dist/phases/transforms/methods/GroupTransform.js

@@ -0,0 +1,39 @@
+import { group, groupX, groupY, groupZ } from 'svelteplot';
+import { GROUP_CHANNEL_KEYS } from '../../../types/transforms/group';
+import { AnchorBar } from './AnchorBar';
+/** The style outputs every group transform can reduce to. */
+const STYLE_OUTPUTS = {
+    fill: true,
+    stroke: true,
+    r: true,
+    opacity: true,
+    fillOpacity: true,
+    strokeOpacity: true
+};
+/** svelteplot's group transforms: along `x`, along `y`, by `z`, or both axes. */
+export class GroupTransform {
+    // Each group transform's position outputs are reducers on the transform, while
+    // the marker's own channel of the same name stays the value they reduce.
+    static x = {
+        channelKeys: GROUP_CHANNEL_KEYS,
+        outputKeys: { y: true, y1: true, y2: true, ...STYLE_OUTPUTS },
+        run: groupX,
+        finish: AnchorBar.toZero('y')
+    };
+    static y = {
+        channelKeys: GROUP_CHANNEL_KEYS,
+        outputKeys: { x: true, x1: true, x2: true, ...STYLE_OUTPUTS },
+        run: groupY,
+        finish: AnchorBar.toZero('x')
+    };
+    static z = {
+        channelKeys: GROUP_CHANNEL_KEYS,
+        outputKeys: { x: true, x1: true, x2: true, y: true, y1: true, y2: true, ...STYLE_OUTPUTS },
+        run: groupZ
+    };
+    static grid = {
+        channelKeys: GROUP_CHANNEL_KEYS,
+        outputKeys: STYLE_OUTPUTS,
+        run: group
+    };
+}

package/dist/phases/transforms/methods/NormalizeTransform.d.ts

@@ -0,0 +1,10 @@
+import type { TransformAdapter } from '../../../types/phases/transforms/adapter';
+/** Normalize and map transforms, by axis. */
+export declare class NormalizeTransform {
+    static readonly x: TransformAdapter;
+    static readonly y: TransformAdapter;
+    static readonly parallelX: TransformAdapter;
+    static readonly parallelY: TransformAdapter;
+    static readonly mapX: TransformAdapter;
+    static readonly mapY: TransformAdapter;
+}

package/dist/phases/transforms/methods/NormalizeTransform.js

@@ -0,0 +1,30 @@
+import { normalizeX, normalizeY, normalizeParallelX, normalizeParallelY, mapX, mapY } from 'svelteplot';
+import { POSITION_CHANNEL_KEYS } from '../../../types/transforms/common';
+/** Normalize and map transforms, by axis. */
+export class NormalizeTransform {
+    static x = {
+        channelKeys: POSITION_CHANNEL_KEYS,
+        run: normalizeX
+    };
+    static y = {
+        channelKeys: POSITION_CHANNEL_KEYS,
+        run: normalizeY
+    };
+    static parallelX = {
+        channelKeys: POSITION_CHANNEL_KEYS,
+        run: normalizeParallelX
+    };
+    static parallelY = {
+        channelKeys: POSITION_CHANNEL_KEYS,
+        run: normalizeParallelY
+    };
+    // svelteplot takes the mapping itself as the second argument, not an options object.
+    static mapX = {
+        channelKeys: POSITION_CHANNEL_KEYS,
+        run: (channels, options) => mapX(channels, options.map)
+    };
+    static mapY = {
+        channelKeys: POSITION_CHANNEL_KEYS,
+        run: (channels, options) => mapY(channels, options.map)
+    };
+}

package/dist/phases/transforms/methods/OrderTransform.d.ts

@@ -0,0 +1,16 @@
+import type { TransformAdapter } from '../../../types/phases/transforms/adapter';
+/** Transforms that choose and order rows: sort, shuffle, reverse, filter and select. */
+export declare class OrderTransform {
+    #private;
+    static readonly sort: TransformAdapter;
+    static readonly shuffle: TransformAdapter;
+    static readonly reverse: TransformAdapter;
+    static readonly filter: TransformAdapter;
+    static readonly select: TransformAdapter;
+    static readonly first: TransformAdapter;
+    static readonly last: TransformAdapter;
+    static readonly minX: TransformAdapter;
+    static readonly maxX: TransformAdapter;
+    static readonly minY: TransformAdapter;
+    static readonly maxY: TransformAdapter;
+}