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

package/dist/marks/helpers/Regression.svelte.d.ts

@@ -0,0 +1,26 @@
+import type { BaseMarkProps, ChannelAccessor } from '../../types.js';
+type RegressionType = 'linear' | 'quad' | 'poly' | 'exp' | 'log' | 'pow' | 'loess';
+export type RegressionMarkProps = BaseMarkProps & {
+    x: ChannelAccessor;
+    y: ChannelAccessor;
+    type: RegressionType;
+    /**
+     * If order is specified, sets the regression's order to the specified number.
+     * For example, if order is set to 4, the regression generator will perform a
+     * fourth-degree polynomial regression. Likewise, if order is set to 2, the
+     * regression generator will perform a quadratic regression. Be careful about
+     * attempting to fit your data with higher order polynomials; though the
+     * regression line will fit your data with a high determination coefficient,
+     * it may have little predictive power for data outside of your domain.
+     */
+    order: number;
+    base: number;
+    span: number;
+    confidence: number;
+};
+type $$ComponentProps = RegressionMarkProps & {
+    dependent: 'x' | 'y';
+};
+declare const Regression: import("svelte").Component<$$ComponentProps, {}, "">;
+type Regression = ReturnType<typeof Regression>;
+export default Regression;

package/dist/marks/helpers/events.d.ts

@@ -0,0 +1,8 @@
+import type { BaseMarkProps, DataRecord, PlotState } from '../../types.js';
+export declare function addEventHandlers(node: SVGElement, { options, datum, getPlotState }: {
+    options: BaseMarkProps;
+    datum: DataRecord;
+    getPlotState: () => PlotState;
+}): {
+    destroy(): void;
+};

package/dist/marks/helpers/events.js

@@ -0,0 +1,64 @@
+import { pick } from 'es-toolkit';
+export function addEventHandlers(node, { options, datum, getPlotState }) {
+    const events = pick(options, [
+        'onclick',
+        'oncontextmenu',
+        'ondblclick',
+        'ondrag',
+        'ondragend',
+        'ondragenter',
+        'ondragleave',
+        'ondragover',
+        'ondragstart',
+        'ondrop',
+        'onmousedown',
+        'onmouseenter',
+        'onmouseleave',
+        'onmousemove',
+        'onmouseout',
+        'onmouseup',
+        'onwheel',
+        'ontouchcancel',
+        'ontouchend',
+        'ontouchmove'
+    ]);
+    const listeners = new Map();
+    // attach event handlers
+    for (const [eventName, eventHandler] of Object.entries(events)) {
+        if (eventHandler) {
+            const wrappedHandler = (origEvent) => {
+                const { scales } = getPlotState();
+                if (origEvent.layerX !== undefined) {
+                    if (scales.projection) {
+                        const [x, y] = scales.projection.invert([
+                            origEvent.layerX,
+                            origEvent.layerY
+                        ]);
+                        origEvent.dataX = x;
+                        origEvent.dataY = y;
+                    }
+                    else {
+                        origEvent.dataX =
+                            scales.x.fn.invert && scales.x.fn.invert(origEvent.layerX);
+                        origEvent.dataY =
+                            scales.y.fn.invert && scales.y.fn.invert(origEvent.layerY);
+                    }
+                }
+                eventHandler(origEvent, datum.___orig___ !== undefined ? datum.___orig___ : datum);
+            };
+            listeners.set(eventName, wrappedHandler);
+            node.addEventListener(eventName.substring(2), wrappedHandler);
+        }
+    }
+    if (events.onclick || events.onmousedown || events.onmouseup) {
+        // force role button
+        node.setAttribute('role', 'button');
+    }
+    return {
+        destroy() {
+            for (const [eventName, handler] of listeners.entries()) {
+                node.removeEventListener(eventName.substring(2), handler);
+            }
+        }
+    };
+}

package/dist/transforms/bin.d.ts

@@ -0,0 +1,51 @@
+import type { DataRecord, RawValue } from '../types.js';
+import type { TransformArg } from '../types.js';
+import { type ThresholdCountGenerator } from 'd3-array';
+import { Reducer, type ReducerName } from '../helpers/reduce.js';
+type NamedThresholdsGenerator = 'auto' | 'scott' | 'sturges' | 'freedman-diaconis';
+type BinBaseOptions = {
+    domain?: [number, number];
+    thresholds?: NamedThresholdsGenerator | number | number[] | ThresholdCountGenerator;
+    interval?: number | string;
+    cumulative?: false | 1 | -1;
+    reverse?: boolean;
+};
+type ReducerOption = ReducerName | ((group: DataRecord[]) => RawValue);
+type AdditionalOutputChannels = Partial<{
+    fill: ReducerOption;
+    stroke: ReducerOption;
+    r: ReducerOption;
+    opacity: ReducerOption;
+    fillOpacity: ReducerOption;
+    strokeOpacity: ReducerOption;
+}>;
+export type BinXOptions = BinBaseOptions & AdditionalOutputChannels & Partial<{
+    y: typeof Reducer;
+    y1: typeof Reducer;
+    y2: typeof Reducer;
+}>;
+export type BinYOptions = BinBaseOptions & AdditionalOutputChannels & Partial<{
+    x: typeof Reducer;
+    x1: typeof Reducer;
+    x2: typeof Reducer;
+}>;
+type BinOptions = BinBaseOptions & AdditionalOutputChannels;
+/**
+ * Bins on x. Also groups on y and the first channel of z, fill, or stroke, if any.
+ *
+ * @param param0
+ * @param options
+ */
+export declare function binX<T>({ data, ...channels }: TransformArg<T, DataRecord>, options?: BinXOptions): TransformArg<T, DataRecord>;
+/**
+ * Bins on y. Also groups on y and the first channel of z, fill, or stroke, if any.
+ *
+ * @param param0
+ * @param options
+ */
+export declare function binY<T>({ data, ...channels }: TransformArg<T, DataRecord>, options?: BinYOptions): TransformArg<T, DataRecord>;
+/**
+ * for binning in x and y dimension simulatenously
+ */
+export declare function bin<T>({ data, ...channels }: TransformArg<T, DataRecord>, options?: BinOptions): TransformArg<T, DataRecord>;
+export {};

package/dist/transforms/bin.js

@@ -0,0 +1,171 @@
+import { resolveChannel } from '../helpers/resolve.js';
+import { maybeInterval } from '../helpers/autoTicks.js';
+import { bin as d3Bin, extent, groups as d3Groups, thresholdFreedmanDiaconis, thresholdScott, thresholdSturges } from 'd3-array';
+import { Reducer, reduceOutputs } from '../helpers/reduce.js';
+import { groupFacetsAndZ } from '../helpers/group.js';
+import { isDate } from '../helpers/typeChecks';
+const ThresholdGenerators = {
+    auto: thresholdScott,
+    scott: thresholdScott,
+    sturges: thresholdSturges,
+    'freedman-diaconis': thresholdFreedmanDiaconis
+};
+function binBy(byDim, { data, ...channels }, options) {
+    const { domain, thresholds = 'auto', interval } = options;
+    const bin = d3Bin();
+    if (domain)
+        bin.domain(domain);
+    if (interval) {
+        const [lo, hi] = extent(data.map((d) => resolveChannel(byDim, d, channels)));
+        bin.thresholds(maybeInterval(interval).range(lo, hi));
+    }
+    else if (thresholds)
+        bin.thresholds(
+        // use a generator
+        typeof thresholds === 'string' && ThresholdGenerators[thresholds] !== undefined
+            ? ThresholdGenerators[thresholds]
+            : thresholds);
+    // channels.x is the input
+    bin.value((d) => resolveChannel(byDim, d, channels));
+    // y, y1, y2, fill, stroke, etc are outputs
+    const outputs = [
+        ...(byDim === 'x' ? ['y', 'y1', 'y2'] : ['x', 'x1', 'x2']),
+        'fill',
+        'stroke',
+        'r',
+        'opacity',
+        'fillOpacity',
+        'strokeOpacity'
+    ];
+    let newChannels = {
+        [byDim === 'x' ? 'insetLeft' : 'insetTop']: 0.5,
+        [byDim === 'x' ? 'insetRight' : 'insetBottom']: 0.5,
+        ...channels,
+        [`${byDim}`]: `__${byDim}`,
+        [`${byDim}1`]: `__${byDim}1`,
+        [`${byDim}2`]: `__${byDim}2`,
+        [`__${byDim}_origField`]: typeof channels[byDim] === 'string' ? channels[byDim] : null
+    };
+    const newData = [];
+    let passedGroups = [];
+    const bins = bin(data);
+    (options.cumulative < 0 ? bins.toReversed() : bins).forEach((group) => {
+        const itemBinProps = {
+            [`__${byDim}1`]: group.x0,
+            [`__${byDim}2`]: group.x1,
+            [`__${byDim}`]: isDate(group.x0)
+                ? new Date(Math.round((group.x0.getTime() + group.x1.getTime()) * 0.5))
+                : (group.x0 + group.x1) * 0.5
+        };
+        if (options.cumulative)
+            passedGroups = [...passedGroups, ...group];
+        const newGroupChannels = groupFacetsAndZ(options.cumulative ? passedGroups : group, channels, (items, itemGroupProps) => {
+            const item = { ...itemBinProps, ...itemGroupProps };
+            reduceOutputs(item, items, options, outputs, channels, newChannels);
+            newData.push(item);
+        });
+        newChannels = { ...newChannels, ...newGroupChannels };
+    });
+    return { data: options.reverse ? newData.toReversed() : newData, ...newChannels };
+}
+/**
+ * Bins on x. Also groups on y and the first channel of z, fill, or stroke, if any.
+ *
+ * @param param0
+ * @param options
+ */
+export function binX({ data, ...channels }, options = { thresholds: 'auto', cumulative: false }) {
+    return binBy('x', { data, ...channels }, options);
+}
+/**
+ * Bins on y. Also groups on y and the first channel of z, fill, or stroke, if any.
+ *
+ * @param param0
+ * @param options
+ */
+export function binY({ data, ...channels }, options = { thresholds: 'auto', cumulative: false }) {
+    return binBy('y', { data, ...channels }, options);
+}
+/**
+ * for binning in x and y dimension simulatenously
+ */
+export function bin({ data, ...channels }, options = { thresholds: 'auto', cumulative: false }) {
+    const { domain, thresholds = 'auto', interval, cumulative = false } = options;
+    const binX = d3Bin();
+    const binY = d3Bin();
+    if (domain) {
+        // this really doesn't make sense...
+        binX.domain(domain);
+        binY.domain(domain);
+    }
+    // channels.x is the input
+    binX.value((d) => resolveChannel('x', d, channels));
+    binY.value((d) => resolveChannel('y', d, channels));
+    if (interval) {
+        const [xlo, xhi] = extent(data.map((d) => resolveChannel('x', d, channels)));
+        const [ylo, yhi] = extent(data.map((d) => resolveChannel('y', d, channels)));
+        binX.thresholds(maybeInterval(interval).range(xlo, xhi));
+        binY.thresholds(maybeInterval(interval).range(ylo, yhi));
+    }
+    else if (thresholds) {
+        // when binning in x and y, we need to ensure we are using consistent thresholds
+        const t = typeof thresholds === 'string' && ThresholdGenerators[thresholds] !== undefined
+            ? ThresholdGenerators[thresholds]
+            : thresholds;
+        binX.thresholds(t);
+        binY.thresholds(t);
+        const yThresholds = binY(data)
+            .slice(1)
+            .map((g) => g.x0);
+        binY.thresholds(yThresholds);
+    }
+    // y, y1, y2, fill, stroke, etc are outputs
+    const outputs = ['fill', 'stroke', 'r', 'opacity', 'fillOpacity', 'strokeOpacity'];
+    let newChannels = {
+        inset: 0.5,
+        ...channels,
+        x: '__x',
+        x1: '__x1',
+        x2: '__x2',
+        y: '__y',
+        y1: '__y1',
+        y2: '__y2',
+        __x_origField: typeof channels.x === 'string' ? channels.x : null,
+        __y_origField: typeof channels.y === 'string' ? channels.y : null
+    };
+    const groupBy = channels.z ? 'z' : channels.fill ? 'fill' : channels.stroke ? 'stroke' : true;
+    const groupByPropName = groupBy !== true && typeof channels[groupBy] === 'string' ? channels[groupBy] : '__group';
+    if (groupBy !== true)
+        newChannels[groupBy] = groupByPropName;
+    // consistent intervals
+    const newData = [];
+    binX(data).forEach((groupX) => {
+        const newRecordBaseX = {
+            __x1: groupX.x0,
+            __x2: groupX.x1,
+            __x: isDate(groupX.x0)
+                ? new Date(Math.round((groupX.x0.getTime() + groupX.x1.getTime()) * 0.5))
+                : (groupX.x0 + groupX.x1) * 0.5
+        };
+        binY(groupX).forEach((groupY) => {
+            const newRecordBaseY = {
+                ...newRecordBaseX,
+                __y1: groupY.x0,
+                __y2: groupY.x1,
+                __y: isDate(groupY.x0)
+                    ? new Date(Math.round((groupY.x0.getTime() + groupY.x1.getTime()) * 0.5))
+                    : (groupY.x0 + groupY.x1) * 0.5
+            };
+            const newGroupChannels = groupFacetsAndZ(groupY, channels, (items, itemGroupProps) => {
+                const newRecord = {
+                    ...newRecordBaseY,
+                    ...itemGroupProps
+                };
+                reduceOutputs(newRecord, items, options, outputs, channels, newChannels);
+                newData.push(newRecord);
+            });
+            newChannels = { ...newChannels, ...newGroupChannels };
+        });
+    });
+    return { data: options.reverse ? newData.toReversed() : newData, ...newChannels };
+}

package/dist/transforms/bollinger.d.ts

@@ -0,0 +1,21 @@
+import type { DataRecord, TransformArg } from '../types.js';
+export type BollingerOptions = {
+    /**
+     * the window size (the window transform’s k option), an integer; defaults to 20
+     */
+    n?: number;
+    /**
+     * the band radius, a number representing a multiple of standard deviations; defaults to 2
+     */
+    k?: number;
+};
+export declare function bollingerX(args: TransformArg<DataRecord>, options?: BollingerOptions): TransformArg<DataRecord>;
+export declare function bollingerY(args: TransformArg<DataRecord>, options?: BollingerOptions): TransformArg<DataRecord>;
+export declare function bollingerDim(dim: 'x' | 'y', { data, ...channels }: TransformArg<DataRecord>, options?: BollingerOptions): {
+    data: {
+        __x: import("../types.js").RawValue;
+        __lo: number;
+        __avg: number;
+        __hi: number;
+    }[];
+};

package/dist/transforms/bollinger.js

@@ -0,0 +1,53 @@
+import { resolveChannel } from '../helpers/resolve.js';
+export function bollingerX(args, options = {}) {
+    return bollingerDim('x', args, options);
+}
+export function bollingerY(args, options = {}) {
+    return bollingerDim('y', args, options);
+}
+export function bollingerDim(dim, { data, ...channels }, options = {}) {
+    const { n = 20, k = 2 } = options;
+    const bands = bollinger(data.map((datum) => resolveChannel(dim, datum, channels)), n, [-k, 0, k]);
+    const otherDim = dim === 'x' ? 'y' : 'x';
+    return {
+        data: data.map((datum, i) => ({
+            __x: resolveChannel(otherDim, datum, channels),
+            __lo: bands[0][i],
+            __avg: bands[1][i],
+            __hi: bands[2][i]
+        })),
+        ...channels,
+        [otherDim]: '__x',
+        [dim]: '__avg',
+        [`${otherDim}1`]: '__x',
+        [`${dim}1`]: '__lo',
+        [`${dim}2`]: '__hi'
+    };
+}
+/**
+ * taken from https://observablehq.com/@d3/bollinger-bands/
+ */
+function bollinger(values, N, K) {
+    let i = 0;
+    let sum = 0;
+    let sumSquared = 0;
+    // initialize bands
+    const bands = K.map(() => new Float64Array(values.length).fill(NaN));
+    // compute sum and square of sums
+    for (let n = Math.min(N - 1, values.length); i < n; ++i) {
+        const value = values[i];
+        (sum += value), (sumSquared += value ** 2);
+    }
+    for (let n = values.length, m = bands.length; i < n; ++i) {
+        const value = values[i];
+        (sum += value), (sumSquared += value ** 2);
+        const mean = sum / N;
+        const deviation = Math.sqrt((sumSquared - sum ** 2 / N) / (N - 1));
+        for (let j = 0; j < K.length; ++j) {
+            bands[j][i] = mean + deviation * K[j];
+        }
+        const value0 = values[i - N + 1];
+        (sum -= value0), (sumSquared -= value0 ** 2);
+    }
+    return bands;
+}

package/dist/transforms/centroid.d.ts

@@ -0,0 +1,9 @@
+import type { DataRecord, TransformArg } from '../types.js';
+export declare function geoCentroid({ data, ...options }: TransformArg<DataRecord>): {
+    x: (d: any) => any;
+    y: (d: any) => any;
+    data: {
+        __centroid__: [number, number];
+        ___orig___?: import("../types.js").RawValue | [import("../types.js").RawValue, import("../types.js").RawValue];
+    }[];
+};

package/dist/transforms/centroid.js

@@ -0,0 +1,13 @@
+import { resolveProp } from '../helpers/resolve.js';
+import { geoCentroid as d3GeoCentroid } from 'd3-geo';
+export function geoCentroid({ data, ...options }) {
+    return {
+        data: data.map((d) => ({
+            ...d,
+            __centroid__: d3GeoCentroid(resolveProp(options.geometry, d, d))
+        })),
+        ...options,
+        x: (d) => d.__centroid__[0],
+        y: (d) => d.__centroid__[1]
+    };
+}

package/dist/transforms/facet.d.ts

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

package/dist/transforms/facet.js

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

package/dist/transforms/filter.d.ts

@@ -0,0 +1,2 @@
+import type { DataRecord, TransformArg } from '../types.js';
+export declare function filter({ data, ...channels }: TransformArg<DataRecord>): TransformArg<DataRecord>;

package/dist/transforms/filter.js

@@ -0,0 +1,8 @@
+import { testFilter } from '../helpers/index.js';
+export function filter({ data, ...channels }) {
+    return {
+        data: data.filter((d) => testFilter(d, channels)),
+        ...channels,
+        filter: null
+    };
+}

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