svelteplot 0.0.1-alpha.9 → 0.1.3-next.11

package/dist/transforms/group.d.ts

@@ -0,0 +1,66 @@
+import { type ReducerName } from '../helpers/reduce.js';
+import type { DataRecord, DataRow, RawValue, TransformArg } from '../types.js';
+type ReducerFunc = (group: DataRow[]) => RawValue;
+type ReducerOption = ReducerName | ReducerFunc;
+type GroupBaseOptions = {
+    domain?: [number, number];
+    thresholds?: NamedThresholdsGenerator | number | number[] | ThresholdCountGenerator;
+    interval?: number | string;
+    cumulative?: false | 1 | -1;
+    reverse?: boolean;
+    /**
+     * copy properties from the first element of each group
+     */
+    copy?: string[];
+};
+type AdditionalOutputChannels = Partial<{
+    fill: ReducerOption;
+    stroke: ReducerOption;
+    r: ReducerOption;
+    opacity: ReducerOption;
+    fillOpacity: ReducerOption;
+    strokeOpacity: ReducerOption;
+}>;
+type GroupXOptions = GroupBaseOptions & AdditionalOutputChannels & Partial<{
+    y: ReducerOption;
+    y1: ReducerOption;
+    y2: ReducerOption;
+    xPropName: string;
+}>;
+type GroupYOptions = GroupBaseOptions & AdditionalOutputChannels & Partial<{
+    x: ReducerOption;
+    x1: ReducerOption;
+    x2: ReducerOption;
+    yPropName: string;
+}>;
+type GroupZOptions = GroupXOptions | GroupYOptions;
+/**
+ * groups the dataset by x and y channel and optionally reduces the group items
+ * to output channels fill, stroke, r, opacity, fillOpacity, or strokeOpacity
+ */
+export declare function group({ data, ...channels }: TransformArg<T, DataRecord>, options?: GroupXOptions): {
+    data: DataRecord[];
+};
+/**
+ * groups the dataset by the x channel and optionally reduces the group items
+ * to output channels y, y1, y2, fill, stroke, r, opacity, fillOpacity, or strokeOpacity
+ */
+export declare function groupX(input: TransformArg<T, DataRecord>, options?: GroupXOptions): {
+    data: DataRecord[];
+};
+/**
+ * groups the dataset by the y channel and optionally reduces the group items
+ * to output channels x, x1, x2, fill, stroke, r, opacity, fillOpacity, or strokeOpacity
+ */
+export declare function groupY(input: TransformArg<T, DataRecord>, options?: GroupYOptions): {
+    data: DataRecord[];
+};
+/**
+ * groups the dataset by the z channel and optionally reduces the group items
+ * to output channels x, x1, x2, y, y1, y2, fill, stroke, r, opacity, fillOpacity,
+ * or strokeOpacity
+ */
+export declare function groupZ(input: TransformArg<T, DataRecord>, options?: GroupZOptions): {
+    data: DataRecord[];
+};
+export {};

package/dist/transforms/group.js

@@ -0,0 +1,109 @@
+import { groupFacetsAndZ } from '../helpers/group.js';
+import { testFilter } from '../helpers/index.js';
+import { reduceOutputs } from '../helpers/reduce.js';
+import { resolveChannel } from '../helpers/resolve.js';
+import { groups as d3Groups } from 'd3-array';
+import { omit } from '../helpers';
+import { maybeInterval } from '../helpers/autoTicks.js';
+/**
+ * groups the dataset by x and y channel and optionally reduces the group items
+ * to output channels fill, stroke, r, opacity, fillOpacity, or strokeOpacity
+ */
+export function group({ data, ...channels }, options = {}) {
+    if (channels.x == null || channels.y == null)
+        throw new Error('you must provide an x and y channel to group on');
+    // group by x or y
+    const groups = d3Groups(data.filter((d) => testFilter(d, channels)), (d) => resolveChannel('x', d, channels), (d) => resolveChannel('y', d, channels));
+    const newData = [];
+    const xChannel = typeof channels.x === 'string' ? channels.x : '__x';
+    const yChannel = typeof channels.y === 'string' ? channels.y : '__y';
+    let newChannels = omit({ ...channels, x: xChannel, y: yChannel }, 'filter');
+    const outputs = ['fill', 'stroke', 'r', 'opacity', 'fillOpacity', 'strokeOpacity'];
+    groups.forEach(([xGroupKey, xGroups]) => {
+        xGroups.forEach(([yGroupKey, items]) => {
+            const baseRecord = { [xChannel]: xGroupKey, [yChannel]: yGroupKey }; // dim === 'z' ? {} : { [`__${dim}`]: groupKey };
+            // copy properties from first item of each group
+            options.copy?.forEach((prop) => {
+                baseRecord[prop] = items[0][prop];
+            });
+            const newGroupChannels = groupFacetsAndZ(items, channels, (items, itemGroupProps) => {
+                const item = { ...baseRecord, ...itemGroupProps };
+                reduceOutputs(item, items, options, outputs, channels, newChannels);
+                newData.push(item);
+            });
+            newChannels = { ...newChannels, ...newGroupChannels };
+        });
+    });
+    return { data: newData, ...newChannels };
+}
+/**
+ * groups the dataset by the x channel and optionally reduces the group items
+ * to output channels y, y1, y2, fill, stroke, r, opacity, fillOpacity, or strokeOpacity
+ */
+export function groupX(input, options = {}) {
+    return groupXYZ('x', input, options);
+}
+/**
+ * groups the dataset by the y channel and optionally reduces the group items
+ * to output channels x, x1, x2, fill, stroke, r, opacity, fillOpacity, or strokeOpacity
+ */
+export function groupY(input, options = {}) {
+    return groupXYZ('y', input, options);
+}
+/**
+ * groups the dataset by the z channel and optionally reduces the group items
+ * to output channels x, x1, x2, y, y1, y2, fill, stroke, r, opacity, fillOpacity,
+ * or strokeOpacity
+ */
+export function groupZ(input, options = {}) {
+    return groupXYZ('z', input, options);
+}
+function groupXYZ(dim, { data, ...channels }, options = {}) {
+    if ((dim === 'z' ? channels.z || channels.fill || channels.stroke : channels[dim]) == null)
+        throw new Error('you must provide a channel to group on ' + dim);
+    const propName = options[`${dim}PropName`] != null
+        ? options[`${dim}PropName`]
+        : typeof channels[dim] === 'string' && !options.interval
+            ? channels[dim]
+            : `__${dim}`;
+    const interval = options.interval ? maybeInterval(options.interval) : null;
+    // group by x or y
+    const groups = dim === 'z'
+        ? [[null, data]]
+        : d3Groups(data.filter((d) => testFilter(d, channels)), (d) => {
+            const v = resolveChannel(dim, d, channels);
+            return interval ? interval.round(v) : v;
+        });
+    const newData = [];
+    let newChannels = omit({ ...channels }, 'filter');
+    if (dim !== 'z')
+        newChannels[dim] = propName;
+    const outputs = [
+        ...(dim === 'x'
+            ? ['y', 'y1', 'y2']
+            : dim === 'y'
+                ? ['x', 'x1', 'x2']
+                : ['x', 'x1', 'x2', 'y', 'y1', 'y2']),
+        'fill',
+        'stroke',
+        'r',
+        'opacity',
+        'fillOpacity',
+        'strokeOpacity'
+    ];
+    groups.forEach(([groupKey, items]) => {
+        const baseRecord = dim === 'z' ? {} : { [propName]: groupKey };
+        const newGroupChannels = groupFacetsAndZ(items, channels, (items, itemGroupProps) => {
+            const copiedProps = {};
+            // copy properties from first item of each group
+            options.copy?.forEach((prop) => {
+                copiedProps[prop] = items[0][prop];
+            });
+            const item = { ...baseRecord, ...copiedProps, ...itemGroupProps };
+            reduceOutputs(item, items, options, outputs, channels, newChannels);
+            newData.push(item);
+        });
+        newChannels = { ...newChannels, ...newGroupChannels };
+    });
+    return { data: newData, ...newChannels };
+}

package/dist/transforms/interval.d.ts

@@ -0,0 +1,11 @@
+import type { PlotState, TransformArg } from '../types.js';
+export declare function intervalX<T>(args: TransformArg<T>, { plot }: {
+    plot: PlotState;
+}): {
+    data: T[];
+};
+export declare function intervalY<T>(args: TransformArg<T>, { plot }: {
+    plot: PlotState;
+}): {
+    data: T[];
+};

package/dist/transforms/interval.js

@@ -0,0 +1,34 @@
+import { maybeInterval } from '../helpers/autoTicks.js';
+import { resolveChannel } from '../helpers/resolve.js';
+export function intervalX(args, { plot }) {
+    return interval('x', plot, args);
+}
+export function intervalY(args, { plot }) {
+    return interval('y', plot, args);
+}
+function interval(dim, plot, { data, ...options }) {
+    if (options.interval &&
+        options[dim] &&
+        options[`${dim}1`] == null &&
+        options[`${dim}2`] == null) {
+        // derive x1 and x2 from x+interval
+        const interval = maybeInterval(options.interval, plot.scales[dim].type);
+        const newData = data.map((row) => {
+            const val = resolveChannel(dim, row, options);
+            return {
+                ...row,
+                [`__${dim}1`]: interval.floor(val),
+                [`__${dim}2`]: interval.offset(interval.floor(val))
+            };
+        });
+        return {
+            data: newData,
+            // set default inset
+            [`inset${dim === 'x' ? 'Right' : 'Bottom'}`]: 1,
+            ...options,
+            [`${dim}1`]: `__${dim}1`,
+            [`${dim}2`]: `__${dim}2`
+        };
+    }
+    return { data, ...options };
+}

package/dist/transforms/jitter.js

@@ -0,0 +1 @@
+"use strict";

package/dist/transforms/map.d.ts

@@ -0,0 +1,10 @@
+import type { TransformArg, MapOptions, MapMethod, DataRecord } from '../types.js';
+export declare function map<T>(args: TransformArg<T>, options: MapOptions): {
+    data: DataRecord[];
+};
+export declare function mapX<T>(args: TransformArg<T>, mapper: MapMethod): {
+    data: DataRecord[];
+};
+export declare function mapY<T>(args: TransformArg<T>, mapper: MapMethod): {
+    data: DataRecord[];
+};

package/dist/transforms/map.js

@@ -0,0 +1,89 @@
+import { identity } from '../helpers/index.js';
+import { count, rank } from 'd3-array';
+import { groupFacetsAndZ } from '../helpers/group.js';
+import { resolveChannel } from '../helpers/resolve.js';
+export function map(args, options) {
+    const { data, ...channels } = args;
+    const newChannels = {};
+    const newData = [];
+    groupFacetsAndZ(data, channels, (groupedData) => {
+        for (const [channel, map] of Object.entries(options)) {
+            const mapper = maybeMap(map);
+            const values = groupedData.map((d) => resolveChannel(channel, d, channels));
+            const indices = groupedData.map((d, i) => i);
+            const mappedValues = new Array(values.length);
+            mapper.mapIndex(indices, values, mappedValues);
+            newChannels[channel] = `__${channel}`;
+            for (let i = 0; i < values.length; ++i) {
+                const datum = { ...groupedData[i], [`__${channel}`]: mappedValues[i] };
+                newData.push(datum);
+            }
+        }
+    });
+    return { data: newData, ...channels, ...newChannels };
+}
+export function mapX(args, mapper) {
+    let { x, x1, x2 } = args;
+    if (x === undefined && x1 === undefined && x2 === undefined)
+        args = { ...args, x: identity };
+    const outputs = {};
+    if (x != null)
+        outputs.x = mapper;
+    if (x1 != null)
+        outputs.x1 = mapper;
+    if (x2 != null)
+        outputs.x2 = mapper;
+    return map(args, outputs);
+}
+export function mapY(args, mapper) {
+    let { y, y1, y2 } = args;
+    if (y === undefined && y1 === undefined && y2 === undefined)
+        args = { ...args, y: identity };
+    const outputs = {};
+    if (y != null)
+        outputs.y = mapper;
+    if (y1 != null)
+        outputs.y1 = mapper;
+    if (y2 != null)
+        outputs.y2 = mapper;
+    return map(args, outputs);
+}
+function maybeMap(map) {
+    if (map == null)
+        throw new Error('missing map');
+    if (typeof map === 'object' && typeof map.mapIndex === 'function')
+        return map;
+    if (typeof map === 'function')
+        return mapFunction(map);
+    switch (`${map}`.toLowerCase()) {
+        case 'cumsum':
+            return mapCumsum;
+        case 'rank':
+            return mapFunction((I, V) => rank(I, (i) => V[i]));
+        case 'quantile':
+            return mapFunction((I, V) => rankQuantile(I, (i) => V[i]));
+    }
+    throw new Error(`invalid map: ${map}`);
+}
+function rankQuantile(I, f) {
+    const n = count(I, f) - 1;
+    return rank(I, f).map((r) => r / n);
+}
+function mapFunction(f) {
+    return {
+        mapIndex(I, S, T) {
+            const M = f(I, S);
+            if (M.length !== I.length)
+                throw new Error('map function returned a mismatched length');
+            for (let i = 0, n = I.length; i < n; ++i)
+                T[I[i]] = M[i];
+        }
+    };
+}
+const mapCumsum = {
+    mapIndex(I, S, T) {
+        let sum = 0;
+        for (const i of I)
+            T[i] = sum += S[i];
+    }
+};

package/dist/transforms/normalize.d.ts

@@ -0,0 +1,9 @@
+import type { TransformArg, MapIndexObject } from '../types.js';
+type NormalizeBasis = 'deviation' | 'first' | 'last' | 'min' | 'max' | 'mean' | 'median' | 'sum' | 'extent' | MapIndexObject;
+export declare function normalizeX<T>(args: TransformArg<T>, basis: NormalizeBasis): {
+    data: import("../types.js").DataRecord[];
+};
+export declare function normalizeY<T>(args: TransformArg<T>, basis: NormalizeBasis): {
+    data: import("../types.js").DataRecord[];
+};
+export {};

package/dist/transforms/normalize.js

@@ -0,0 +1,86 @@
+import { mapX, mapY } from './map.js';
+import { min, max, mean, median, sum, deviation, extent } from 'd3-array';
+export function normalizeX(args, basis) {
+    return mapX(args, normalize(basis));
+}
+export function normalizeY(args, basis) {
+    return mapY(args, normalize(basis));
+}
+function normalize(basis) {
+    if (basis === undefined)
+        return normalizeFirst;
+    if (typeof basis === 'function')
+        return normalizeBasis(basis);
+    //   if (/^p\d{2}$/i.test(basis)) return normalizeAccessor(percentile(basis));
+    switch (`${basis}`.toLowerCase()) {
+        case 'deviation':
+            return normalizeDeviation;
+        case 'first':
+            return normalizeFirst;
+        case 'last':
+            return normalizeLast;
+        case 'max':
+            return normalizeMax;
+        case 'mean':
+            return normalizeMean;
+        case 'median':
+            return normalizeMedian;
+        case 'min':
+            return normalizeMin;
+        case 'sum':
+            return normalizeSum;
+        case 'extent':
+            return normalizeExtent;
+    }
+    throw new Error(`invalid basis: ${basis}`);
+}
+function normalizeBasis(basis) {
+    return {
+        mapIndex(I, S, T) {
+            const b = +basis(I, S);
+            for (const i of I) {
+                T[i] = S[i] === null ? NaN : S[i] / b;
+            }
+        }
+    };
+}
+function normalizeAccessor(f) {
+    return normalizeBasis((I, S) => f(I, (i) => S[i]));
+}
+const normalizeExtent = {
+    mapIndex(I, S, T) {
+        const [s1, s2] = extent(I, (i) => S[i]);
+        const d = s2 - s1;
+        for (const i of I) {
+            T[i] = S[i] === null ? NaN : (S[i] - s1) / d;
+        }
+    }
+};
+const normalizeFirst = normalizeBasis((I, S) => {
+    for (let i = 0; i < I.length; ++i) {
+        const s = S[I[i]];
+        if (s != null && isFinite(s))
+            return s;
+    }
+});
+const normalizeLast = normalizeBasis((I, S) => {
+    for (let i = I.length - 1; i >= 0; --i) {
+        const s = S[I[i]];
+        if (s != null && isFinite(s))
+            return s;
+    }
+});
+const normalizeDeviation = {
+    mapIndex(I, S, T) {
+        const m = mean(I, (i) => S[i]);
+        const d = deviation(I, (i) => S[i]);
+        for (const i of I) {
+            T[i] = S[i] === null ? NaN : d ? (S[i] - m) / d : 0;
+        }
+    }
+};
+const normalizeMax = normalizeAccessor(max);
+const normalizeMean = normalizeAccessor(mean);
+const normalizeMedian = normalizeAccessor(median);
+const normalizeMin = normalizeAccessor(min);
+const normalizeSum = normalizeAccessor(sum);

package/dist/transforms/recordize.d.ts

@@ -0,0 +1,14 @@
+import type { TransformArgsRow, TransformArgsRecord } from '../types.js';
+export declare const RAW_VALUE: unique symbol;
+export declare function recordizeX({ data, ...channels }: TransformArgsRow, { withIndex }?: {
+    withIndex: boolean;
+}): TransformArgsRecord;
+export declare function recordizeY({ data, ...channels }: TransformArgsRow, { withIndex }?: {
+    withIndex: boolean;
+}): TransformArgsRecord;
+/**
+ * This transform is used to allow users to pass an [[x0, y0], [x1, y1], ...] array
+ * as dataset to marks that support it. It transforms the arrays into records, so
+ * the rest of our code doesn't have to deal with this case anymore.
+ */
+export declare function recordizeXY({ data, ...channels }: TransformArgsRow): TransformArgsRecord;

package/dist/transforms/recordize.js

@@ -0,0 +1,79 @@
+import isDataRecord from '../helpers/isDataRecord.js';
+export const RAW_VALUE = Symbol();
+/*
+ * This transform takes an array of raw values as input and returns data records
+ * in which the values are interpreted as x channel and their index as y
+ */
+export function recordizeX({ data, ...channels }, { withIndex } = { withIndex: true }) {
+    const dataIsRawValueArray = !isDataRecord(data[0]) && !Array.isArray(data[0]) && channels.x == null;
+    if (dataIsRawValueArray) {
+        return {
+            data: data.map((value, index) => ({
+                __value: value,
+                ...(withIndex ? { __index: index } : {}),
+                [RAW_VALUE]: value,
+                // TODO: remove ___orig___ references
+                ___orig___: value
+            })),
+            ...channels,
+            x: '__value',
+            ...(withIndex ? { y: '__index' } : {})
+        };
+    }
+    return { data: data, ...channels };
+}
+/*
+ * This transform takes an array of raw values as input and returns data records
+ * in which the values are interpreted as y channel and their index as yx
+ */
+export function recordizeY({ data, ...channels }, { withIndex } = { withIndex: true }) {
+    if (!data)
+        return { data, ...channels };
+    const dataIsRawValueArray = !isDataRecord(data[0]) && !Array.isArray(data[0]) && channels.y == null;
+    if (dataIsRawValueArray) {
+        return {
+            data: Array.from(data).map((value, index) => ({
+                __value: value,
+                ...(withIndex ? { __index: index } : {}),
+                [RAW_VALUE]: value,
+                ___orig___: value
+            })),
+            ...channels,
+            ...(withIndex ? { x: '__index' } : {}),
+            y: '__value'
+        };
+    }
+    return {
+        data: Array.from(data).map((d, index) => ({
+            ...d,
+            ...(withIndex ? { __index: index } : {})
+        })),
+        x: '__index',
+        ...channels
+    };
+}
+/**
+ * This transform is used to allow users to pass an [[x0, y0], [x1, y1], ...] array
+ * as dataset to marks that support it. It transforms the arrays into records, so
+ * the rest of our code doesn't have to deal with this case anymore.
+ */
+export function recordizeXY({ data, ...channels }) {
+    if (!data)
+        return { data, ...channels };
+    if (!isDataRecord(data[0]) &&
+        Array.isArray(data[0]) &&
+        channels.x === undefined &&
+        channels.y === undefined) {
+        return {
+            data: data.map(([x, y, ...rest]) => ({
+                ___orig___: [x, y, ...rest],
+                __x: x,
+                __y: y
+            })),
+            ...channels,
+            x: '__x',
+            y: '__y'
+        };
+    }
+    return { data, ...channels };
+}

package/dist/transforms/rename.d.ts

@@ -0,0 +1,14 @@
+import type { DataRecord } from '../types.js';
+import type { ScaledChannelName, TransformArg } from '../types.js';
+type RenameChannelsOptions = Partial<Record<ScaledChannelName, ScaledChannelName>>;
+type ReplaceChannelsOptions = Partial<Record<ScaledChannelName, ScaledChannelName[]>>;
+/**
+ * renames a channel without modifying the data
+ */
+export declare function renameChannels<T>({ data, ...channels }: TransformArg<T, DataRecord>, options: RenameChannelsOptions): TransformArg<T, DataRecord>;
+/**
+ * renames a channel and copy the data
+ */
+export declare function renameChannelsAndData<T>({ data, ...channels }: TransformArg<T, DataRecord>, options: RenameChannelsOptions): TransformArg<T, DataRecord>;
+export declare function replaceChannels<T>({ data, ...channels }: TransformArg<T, DataRecord>, options: ReplaceChannelsOptions): TransformArg<T, DataRecord>;
+export {};

package/dist/transforms/rename.js

@@ -0,0 +1,42 @@
+/**
+ * renames a channel without modifying the data
+ */
+export function renameChannels({ data, ...channels }, options) {
+    const newChannels = channels;
+    for (const [from, to] of Object.entries(options)) {
+        if (newChannels[from] !== undefined) {
+            newChannels[to] = newChannels[from];
+            delete newChannels[from];
+        }
+    }
+    return { data, ...newChannels };
+}
+/**
+ * renames a channel and copy the data
+ */
+export function renameChannelsAndData({ data, ...channels }, options) {
+    const newData = [];
+    for (const datum of data) {
+        const newDatum = { ...datum };
+        for (const [from, to] of Object.entries(options)) {
+            if (channels[from] !== undefined) {
+                newDatum[to] = newDatum[from];
+                delete newDatum[from];
+            }
+        }
+        newData.push(newDatum);
+    }
+    return renameChannels({ data: newData, ...channels }, options);
+}
+export function replaceChannels({ data, ...channels }, options) {
+    const newChannels = { ...channels };
+    for (const [from, to] of Object.entries(options)) {
+        if (newChannels[from] !== undefined) {
+            for (const t of to) {
+                newChannels[t] = newChannels[from];
+            }
+            delete newChannels[from];
+        }
+    }
+    return { data, ...newChannels };
+}

package/dist/transforms/select.d.ts

@@ -0,0 +1,35 @@
+import type { ChannelName, DataRecord, TransformArg } from '../types.js';
+type AtLeastOne<T, U = {
+    [K in keyof T]: Pick<T, K>;
+}> = Partial<T> & U[keyof U];
+type SelectOptions = 'first' | 'last' | AtLeastOne<{
+    [k in ChannelName]: 'min' | 'max';
+}>;
+export declare function select({ data, ...channels }: TransformArg<DataRecord>, options: SelectOptions): {
+    data: DataRecord[];
+};
+/**
+ * Keeps only the first item of each group
+ */
+export declare function selectFirst(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
+/**
+ * Keeps only the last item of each group
+ */
+export declare function selectLast(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
+export declare function selectMinX(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
+export declare function selectMaxX(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
+export declare function selectMinY(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
+export declare function selectMaxY(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
+export {};

package/dist/transforms/select.js

@@ -0,0 +1,55 @@
+import { groupFacetsAndZ } from '../helpers/group.js';
+import { resolveChannel } from '../helpers/resolve.js';
+// let o: SelectOptions = { x: 'min'};
+export function select({ data, ...channels }, options) {
+    const newData = [];
+    groupFacetsAndZ(data, channels, (items) => {
+        if (typeof options === 'string') {
+            if (options !== 'first' && options !== 'last')
+                throw new Error('unknown sort option: ' + options);
+            newData.push(options === 'first' ? items[0] : items.at(-1));
+        }
+        else {
+            const sortOptions = Object.entries(options);
+            if (!sortOptions.length)
+                throw new Error('must provide the channel to sort by');
+            if (sortOptions.length > 1)
+                throw new Error('cannot sort by more than one channel');
+            if (sortOptions[0][1] !== 'min' && sortOptions[0][1] !== 'max')
+                throw new Error('unknown sort option: ' + sortOptions[0][1]);
+            const selected = items
+                .map((item) => ({
+                ...item,
+                __sortby: resolveChannel(sortOptions[0][0], item, channels)
+            }))
+                .sort((a, b) => (a.__sortby > b.__sortby ? 1 : a.__sortby < b.__sortby ? -1 : 0))
+                .at(sortOptions[0][1] === 'min' ? 0 : -1);
+            newData.push(selected);
+        }
+    });
+    return { data: newData, ...channels };
+}
+/**
+ * Keeps only the first item of each group
+ */
+export function selectFirst(args) {
+    return select(args, 'first');
+}
+/**
+ * Keeps only the last item of each group
+ */
+export function selectLast(args) {
+    return select(args, 'last');
+}
+export function selectMinX(args) {
+    return select(args, { x: 'min' });
+}
+export function selectMaxX(args) {
+    return select(args, { x: 'max' });
+}
+export function selectMinY(args) {
+    return select(args, { y: 'min' });
+}
+export function selectMaxY(args) {
+    return select(args, { y: 'max' });
+}