svelteplot 0.4.4 → 0.4.5-pr-208.0

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

@@ -1,74 +1,15 @@
-import type { BaseRectMarkProps } from '../../types/mark.js';
+import type { BaseMarkProps, BaseRectMarkProps } from '../../types/mark.js';
 import type { DataRecord, ScaledDataRecord } from '../../types/data.js';
 import type { UsedScales } from '../../types/index.js';
 declare class __sveltets_Render<Datum extends DataRecord> {
     props(): {
-        datum: ScaledDataRecord<Datum>;
+        datum: ScaledDataRecord<Datum_1>;
         class: string | null;
         x: number;
         y: number;
         width: number;
         height: number;
-        options: BaseRectMarkProps<Datum> & Partial<{
-            filter?: import("../../types/index.js").ConstantAccessor<boolean, Datum>;
-            facet?: "auto" | "include" | "exclude";
-            fx: import("../../types/index.js").ChannelAccessor<Datum>;
-            fy: import("../../types/index.js").ChannelAccessor<Datum>;
-            dx: import("../../types/index.js").ConstantAccessor<number, Datum>;
-            dy: import("../../types/index.js").ConstantAccessor<number, Datum>;
-            fill: import("../../types/index.js").ChannelAccessor<Datum>;
-            fillOpacity: import("../../types/index.js").ConstantAccessor<number, Datum>;
-            sort: {
-                channel: string;
-                order?: "ascending" | "descending";
-            } | ((a: import("../../types/data.js").RawValue, b: import("../../types/data.js").RawValue) => number) | import("../../types/index.js").ConstantAccessor<import("../../types/data.js").RawValue, Datum>;
-            stroke: import("../../types/index.js").ChannelAccessor<Datum>;
-            strokeWidth: import("../../types/index.js").ConstantAccessor<number, Datum>;
-            strokeOpacity: import("../../types/index.js").ConstantAccessor<number, Datum>;
-            strokeLinejoin: import("../../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, Datum>;
-            strokeLinecap: import("../../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, Datum>;
-            strokeMiterlimit: import("../../types/index.js").ConstantAccessor<number, Datum>;
-            opacity: import("../../types/index.js").ChannelAccessor<Datum>;
-            strokeDasharray: import("../../types/index.js").ConstantAccessor<string, Datum>;
-            strokeDashoffset: import("../../types/index.js").ConstantAccessor<number, Datum>;
-            mixBlendMode: import("../../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, Datum>;
-            clipPath: string;
-            imageFilter: import("../../types/index.js").ConstantAccessor<string, Datum>;
-            shapeRendering: import("../../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, Datum>;
-            paintOrder: import("../../types/index.js").ConstantAccessor<string, Datum>;
-            onclick?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ondblclick?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onmouseup?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onmousedown?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onmouseenter?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onmousemove?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onmouseleave?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onmouseout?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onmouseover?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onpointercancel?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onpointerdown?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onpointerup?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onpointerenter?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onpointerleave?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onpointermove?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onpointerover?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onpointerout?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ondrag?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ondrop?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ondragstart?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ondragenter?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ondragleave?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ondragover?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ondragend?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ontouchstart?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ontouchmove?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ontouchend?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ontouchcancel?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            oncontextmenu?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onwheel?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            class: string | null;
-            cursor: import("../../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Datum>;
-        }>;
+        options: BaseRectMarkProps<Datum_1> & BaseMarkProps<Datum_1>;
         /**
          * By default, the `inset` property is applied to all four insets. Mark components
          * can tweak this behavior for insetTop and insetBottom by setting the

package/dist/marks/helpers/Regression.svelte

@@ -43,7 +43,7 @@
         regressionLog,
         regressionPow,
         regressionLoess
-    } from 'd3-regression/dist/d3-regression.esm.js';
+    } from '@gka/d3-regression';
     import { resolveChannel } from '../../helpers/resolve.js';
     import { confidenceInterval } from '../../helpers/math.js';
     import callWithProps from '../../helpers/callWithProps.js';

package/dist/transforms/bollinger.d.ts

@@ -11,69 +11,4 @@ export type BollingerOptions = {
 };
 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): {
-    filter?: import("../types/index.js").ConstantAccessor<boolean, Record<string | symbol, import("../types/index.js").RawValue>>;
-    facet?: "auto" | "include" | "exclude" | undefined;
-    fx?: import("../types/index.js").ChannelAccessor<Record<string | symbol, import("../types/index.js").RawValue>>;
-    fy?: import("../types/index.js").ChannelAccessor<Record<string | symbol, import("../types/index.js").RawValue>>;
-    dx?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/index.js").RawValue>>;
-    dy?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/index.js").RawValue>>;
-    fill?: import("../types/index.js").ChannelAccessor<Record<string | symbol, import("../types/index.js").RawValue>>;
-    fillOpacity?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/index.js").RawValue>>;
-    sort?: {
-        channel: string;
-        order?: "ascending" | "descending";
-    } | ((a: import("../types/index.js").RawValue, b: import("../types/index.js").RawValue) => number) | import("../types/index.js").ConstantAccessor<import("../types/index.js").RawValue, Record<string | symbol, import("../types/index.js").RawValue>>;
-    stroke?: import("../types/index.js").ChannelAccessor<Record<string | symbol, import("../types/index.js").RawValue>>;
-    strokeWidth?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/index.js").RawValue>>;
-    strokeOpacity?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/index.js").RawValue>>;
-    strokeLinejoin?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, Record<string | symbol, import("../types/index.js").RawValue>>;
-    strokeLinecap?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, Record<string | symbol, import("../types/index.js").RawValue>>;
-    strokeMiterlimit?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/index.js").RawValue>>;
-    opacity?: import("../types/index.js").ChannelAccessor<Record<string | symbol, import("../types/index.js").RawValue>>;
-    strokeDasharray?: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/index.js").RawValue>>;
-    strokeDashoffset?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/index.js").RawValue>>;
-    mixBlendMode?: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, Record<string | symbol, import("../types/index.js").RawValue>>;
-    clipPath?: string | undefined;
-    imageFilter?: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/index.js").RawValue>>;
-    shapeRendering?: import("../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, Record<string | symbol, import("../types/index.js").RawValue>>;
-    paintOrder?: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/index.js").RawValue>>;
-    onclick?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondblclick?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseup?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmousedown?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmousemove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseout?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointercancel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerdown?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerup?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointermove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerout?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondrag?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondrop?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragstart?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragend?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchstart?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchmove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchend?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchcancel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    oncontextmenu?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onwheel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    class?: string | null | undefined;
-    cursor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Record<string | symbol, import("../types/index.js").RawValue>>;
-    data: {
-        __x: import("../types/index.js").RawValue;
-        __lo: number;
-        __avg: number;
-        __hi: number;
-    }[];
-};
+export declare function bollingerDim(dim: 'x' | 'y', { data, ...channels }: TransformArg<DataRecord>, options?: BollingerOptions): any;

package/dist/transforms/dodge.d.ts

@@ -0,0 +1,17 @@
+import type { ScaledDataRecord, TransformArg, PlotState } from '../types';
+type BaseDodgeOptions = {
+    anchor?: string;
+    padding?: number;
+    r?: number;
+};
+type AnchorX = 'left' | 'right' | 'middle';
+type AnchorY = 'top' | 'bottom' | 'middle';
+export type DodgeXOptions = AnchorX | (BaseDodgeOptions & {
+    anchor?: 'left' | 'right' | 'middle';
+});
+export type DodgeYOptions = AnchorY | (BaseDodgeOptions & {
+    anchor?: 'top' | 'bottom' | 'middle';
+});
+export declare function dodgeX(args: TransformArg<ScaledDataRecord>, plotState: PlotState): ScaledDataRecord[];
+export declare function dodgeY(args: TransformArg<ScaledDataRecord>, plotState: PlotState): ScaledDataRecord[];
+export {};

package/dist/transforms/dodge.js

@@ -0,0 +1,128 @@
+import IntervalTree from 'interval-tree-1d';
+import { groupFacetsAndZ } from '../helpers/group';
+export function dodgeX(args, plotState) {
+    if (!args.dodgeX)
+        return args.data;
+    let { anchor = 'left', padding = 1, r = args.dodgeX.r } = maybeAnchor(args.dodgeX);
+    let anchorFunction;
+    switch (`${anchor}`.toLowerCase()) {
+        case 'left':
+            anchorFunction = anchorXLeft;
+            break;
+        case 'right':
+            anchorFunction = anchorXRight;
+            break;
+        case 'middle':
+            anchorFunction = anchorXMiddle;
+            break;
+        default:
+            throw new Error(`unknown dodge anchor: ${anchor}`);
+    }
+    return dodge('x', 'y', anchorFunction, Number(padding), r, args, plotState);
+}
+export function dodgeY(args, plotState) {
+    if (!args.dodgeY)
+        return args.data;
+    let { anchor = 'bottom', padding = 1, r = args.dodgeY.r } = maybeAnchor(args.dodgeY);
+    let anchorFunction;
+    switch (`${anchor}`.toLowerCase()) {
+        case 'top':
+            anchorFunction = anchorYTop;
+            break;
+        case 'bottom':
+            anchorFunction = anchorYBottom;
+            break;
+        case 'middle':
+            anchorFunction = anchorYMiddle;
+            break;
+        default:
+            throw new Error(`unknown dodge anchor: ${anchor}`);
+    }
+    return dodge('y', 'x', anchorFunction, Number(padding), r, args, plotState);
+}
+function dodge(y, x, anchor, padding, r, { data, ...channels }, plotState) {
+    if (r != null && typeof r !== 'number') {
+        // use the r channel
+        // let { channels, sort, reverse } = options;
+        // channels = maybeNamed(channels);
+        // if (channels?.r === undefined)
+        //     options = { ...options, channels: { ...channels, r: { value: r, scale: 'r' } } };
+        // if (sort === undefined && reverse === undefined) options.sort = { channel: '-r' };
+    }
+    const { fx, fy } = channels;
+    let [ky, ty] = anchor(plotState);
+    const compare = ky ? compareAscending : compareSymmetric;
+    const cr = r !== undefined ? r : 3; // default radius if no r channel
+    // group data by facets
+    groupFacetsAndZ(data, { fx, fy }, (items) => {
+        // apply dodge within each facet
+        const tree = IntervalTree();
+        const data = items.filter((d) => (typeof d.r !== 'number' || d.r >= 0) && isFinite(d[x]) && isFinite(d[y]));
+        const intervals = new Float64Array(2 * data.length + 2);
+        data.forEach((d, i) => {
+            const ri = d.r ?? r ?? 3;
+            const y0 = ky ? ri + padding : 0; // offset baseline for varying radius
+            const l = d[x] - ri;
+            const h = d[x] + ri;
+            // The first two positions are 0 to test placing the dot on the baseline.
+            let k = 2;
+            // For any previously placed circles that may overlap this circle, compute
+            // the y-positions that place this circle tangent to these other circles.
+            // https://observablehq.com/@mbostock/circle-offset-along-line
+            tree.queryInterval(l - padding, h + padding, ([, , j]) => {
+                const yj = data[j][y] - y0;
+                const dx = d[x] - data[j][x];
+                const dr = padding + (channels.r ? d.r + data[j].r : 2 * cr);
+                const dy = Math.sqrt(dr * dr - dx * dx);
+                intervals[k++] = yj - dy;
+                intervals[k++] = yj + dy;
+            });
+            // Find the best y-value where this circle can fit.
+            let candidates = intervals.slice(0, k);
+            if (ky)
+                candidates = candidates.filter((y) => y >= 0);
+            out: for (const diff of candidates.sort(compare)) {
+                for (let j = 0; j < k; j += 2) {
+                    if (intervals[j] + 1e-6 < diff && diff < intervals[j + 1] - 1e-6) {
+                        continue out;
+                    }
+                }
+                d[y] = diff + y0;
+                break;
+            }
+            // Insert the placed circle into the interval tree.
+            tree.insert([l, h, i]);
+        });
+        if (!ky)
+            ky = 1;
+        data.forEach((d) => (d[y] = d[y] * ky + ty));
+    });
+    return data;
+}
+function maybeAnchor(anchor) {
+    return typeof anchor === 'string' ? { anchor } : anchor;
+}
+function anchorXLeft({ options: { marginLeft } }) {
+    return [1, marginLeft];
+}
+function anchorXRight({ facetWidth: width, options: { marginLeft } }) {
+    return [-1, marginLeft + width];
+}
+function anchorXMiddle({ facetWidth: width, options: { marginLeft } }) {
+    return [0, marginLeft + width / 2];
+}
+function anchorYTop({ options: { marginTop } }) {
+    return [1, marginTop];
+}
+function anchorYBottom({ facetHeight: height }) {
+    return [-1, height];
+}
+function anchorYMiddle({ facetHeight: height, options: { marginTop, marginBottom } }) {
+    return [0, (marginTop + height) / 2];
+}
+function compareSymmetric(a, b) {
+    return Math.abs(a) - Math.abs(b);
+}
+function compareAscending(a, b) {
+    return a - b;
+}

package/dist/transforms/group.d.ts

@@ -38,29 +38,21 @@ 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: Record<string | symbol, RawValue>[];
-};
+export declare function group({ data, ...channels }: TransformArg<T, DataRecord>, options?: GroupXOptions): any;
 /**
  * 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: Record<string | symbol, RawValue>[];
-};
+export declare function groupX(input: TransformArg<T, DataRecord>, options?: GroupXOptions): any;
 /**
  * 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: Record<string | symbol, RawValue>[];
-};
+export declare function groupY(input: TransformArg<T, DataRecord>, options?: GroupYOptions): any;
 /**
  * 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: Record<string | symbol, RawValue>[];
-};
+export declare function groupZ(input: TransformArg<T, DataRecord>, options?: GroupZOptions): any;
 export {};

package/dist/transforms/interval.d.ts

@@ -1,127 +1,7 @@
 import type { PlotState, TransformArg } from '../types/index.js';
 export declare function intervalX<T>(args: TransformArg<T>, { plot }: {
     plot: PlotState;
-}): {
-    filter?: import("../types/index.js").ConstantAccessor<boolean, T>;
-    facet?: "auto" | "include" | "exclude" | undefined;
-    fx?: import("../types/index.js").ChannelAccessor<T>;
-    fy?: import("../types/index.js").ChannelAccessor<T>;
-    dx?: import("../types/index.js").ConstantAccessor<number, T>;
-    dy?: import("../types/index.js").ConstantAccessor<number, T>;
-    fill?: import("../types/index.js").ChannelAccessor<T>;
-    fillOpacity?: import("../types/index.js").ConstantAccessor<number, T>;
-    sort?: {
-        channel: string;
-        order?: "ascending" | "descending";
-    } | ((a: import("../types/index.js").RawValue, b: import("../types/index.js").RawValue) => number) | import("../types/index.js").ConstantAccessor<import("../types/index.js").RawValue, T>;
-    stroke?: import("../types/index.js").ChannelAccessor<T>;
-    strokeWidth?: import("../types/index.js").ConstantAccessor<number, T>;
-    strokeOpacity?: import("../types/index.js").ConstantAccessor<number, T>;
-    strokeLinejoin?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, T>;
-    strokeLinecap?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, T>;
-    strokeMiterlimit?: import("../types/index.js").ConstantAccessor<number, T>;
-    opacity?: import("../types/index.js").ChannelAccessor<T>;
-    strokeDasharray?: import("../types/index.js").ConstantAccessor<string, T>;
-    strokeDashoffset?: import("../types/index.js").ConstantAccessor<number, T>;
-    mixBlendMode?: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, T>;
-    clipPath?: string | undefined;
-    imageFilter?: import("../types/index.js").ConstantAccessor<string, T>;
-    shapeRendering?: import("../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, T>;
-    paintOrder?: import("../types/index.js").ConstantAccessor<string, T>;
-    onclick?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondblclick?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseup?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmousedown?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmousemove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseout?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointercancel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerdown?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerup?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointermove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerout?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondrag?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondrop?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragstart?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragend?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchstart?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchmove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchend?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchcancel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    oncontextmenu?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onwheel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    class?: string | null | undefined;
-    cursor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, T>;
-    data: T[];
-};
+}): any;
 export declare function intervalY<T>(args: TransformArg<T>, { plot }: {
     plot: PlotState;
-}): {
-    filter?: import("../types/index.js").ConstantAccessor<boolean, T>;
-    facet?: "auto" | "include" | "exclude" | undefined;
-    fx?: import("../types/index.js").ChannelAccessor<T>;
-    fy?: import("../types/index.js").ChannelAccessor<T>;
-    dx?: import("../types/index.js").ConstantAccessor<number, T>;
-    dy?: import("../types/index.js").ConstantAccessor<number, T>;
-    fill?: import("../types/index.js").ChannelAccessor<T>;
-    fillOpacity?: import("../types/index.js").ConstantAccessor<number, T>;
-    sort?: {
-        channel: string;
-        order?: "ascending" | "descending";
-    } | ((a: import("../types/index.js").RawValue, b: import("../types/index.js").RawValue) => number) | import("../types/index.js").ConstantAccessor<import("../types/index.js").RawValue, T>;
-    stroke?: import("../types/index.js").ChannelAccessor<T>;
-    strokeWidth?: import("../types/index.js").ConstantAccessor<number, T>;
-    strokeOpacity?: import("../types/index.js").ConstantAccessor<number, T>;
-    strokeLinejoin?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, T>;
-    strokeLinecap?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, T>;
-    strokeMiterlimit?: import("../types/index.js").ConstantAccessor<number, T>;
-    opacity?: import("../types/index.js").ChannelAccessor<T>;
-    strokeDasharray?: import("../types/index.js").ConstantAccessor<string, T>;
-    strokeDashoffset?: import("../types/index.js").ConstantAccessor<number, T>;
-    mixBlendMode?: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, T>;
-    clipPath?: string | undefined;
-    imageFilter?: import("../types/index.js").ConstantAccessor<string, T>;
-    shapeRendering?: import("../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, T>;
-    paintOrder?: import("../types/index.js").ConstantAccessor<string, T>;
-    onclick?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondblclick?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseup?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmousedown?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmousemove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseout?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointercancel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerdown?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerup?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointermove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerout?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondrag?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondrop?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragstart?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragend?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchstart?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchmove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchend?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchcancel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    oncontextmenu?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onwheel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    class?: string | null | undefined;
-    cursor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, T>;
-    data: T[];
-};
+}): any;

package/dist/transforms/recordize.d.ts

@@ -1,11 +1,8 @@
 import type { TransformArgsRow, TransformArgsRecord } from '../types/index.js';
-import { INDEX } from '../constants';
 export declare const X: unique symbol;
 export declare const Y: unique symbol;
 export declare const RAW_VALUE: unique symbol;
-export declare function indexData<T extends object>(data: T[]): (T & {
-    [INDEX]: number;
-})[];
+export declare function indexData<T extends object>(data: T[]): (T & {})[];
 export declare function recordizeX<T>({ data, ...channels }: TransformArgsRow<T>, { withIndex }?: {
     withIndex: boolean;
 }): TransformArgsRecord<T>;

package/dist/transforms/recordize.js

@@ -13,12 +13,15 @@ export function indexData(data) {
 export function recordizeX({ data, ...channels }, { withIndex } = { withIndex: true }) {
     const dataIsRawValueArray = !isDataRecord(data[0]) && !Array.isArray(data[0]) && channels.x == null;
     if (dataIsRawValueArray) {
+        // we remove x, x1 and x2 from the channels since they make no sense when
+        // the data is a raw value array
+        const { x, x1, x2, ...nonXChannels } = channels;
         return {
             data: data.map((value, index) => ({
                 [RAW_VALUE]: value,
                 [INDEX]: index
             })),
-            ...channels,
+            ...nonXChannels,
             x: RAW_VALUE,
             ...(withIndex ? { y: INDEX } : {})
         };
@@ -34,12 +37,15 @@ export function recordizeY({ data, ...channels }, { withIndex } = { withIndex: t
         return { data, ...channels };
     const dataIsRawValueArray = !isDataRecord(data[0]) && !Array.isArray(data[0]) && channels.y == null;
     if (dataIsRawValueArray) {
+        // we remove y, y1 and y2 from the channels since they make no sense when
+        // the data is a raw value array
+        const { y, y1, y2, ...nonYChannels } = channels;
         return {
             data: Array.from(data).map((value, index) => ({
                 [INDEX]: index,
                 [RAW_VALUE]: value
             })),
-            ...channels,
+            ...nonYChannels,
             ...(withIndex ? { x: INDEX } : {}),
             y: RAW_VALUE
         };