svelteplot 0.9.0 → 0.9.1

package/dist/marks/CellY.svelte

@@ -2,13 +2,15 @@
     @component
     For arbitrary rectangles with fixed x position, requires band y scale
 -->
-<script lang="ts">
+<script lang="ts" generics="Datum extends DataRow">
     import Cell from './Cell.svelte';
     import { recordizeX } from '../index.js';
     import type { ComponentProps } from 'svelte';
-    import type { TransformArgsRow } from '../types/index.js';
+    import type { DataRow, TransformArgsRow } from '../types/index.js';
 
-    interface CellYMarkProps extends Omit<ComponentProps<typeof Cell>, 'x'> {}
+    interface CellYMarkProps extends Omit<ComponentProps<typeof Cell>, 'x' | 'data'> {
+        data: Datum[];
+    }
 
     let { data = [{}], ...options }: CellYMarkProps = $props();
 
@@ -16,7 +18,7 @@
         recordizeX({
             data,
             ...options
-        } as TransformArgsRow)
+        } as TransformArgsRow<Datum>)
     );
 </script>
 

package/dist/marks/CellY.svelte.d.ts

@@ -1,8 +1,95 @@
-import Cell from './Cell.svelte';
-import type { ComponentProps } from 'svelte';
-interface CellYMarkProps extends Omit<ComponentProps<typeof Cell>, 'x'> {
+import type { DataRow } from '../types/index.js';
+declare function $$render<Datum extends DataRow>(): {
+    props: Omit<Partial<{
+        filter: import("../types/index.js").ConstantAccessor<boolean, Record<string | symbol, import("../types/index.js").RawValue>>;
+        facet: "auto" | "include" | "exclude";
+        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>>;
+        dodgeX: import("../transforms/dodge").DodgeXOptions;
+        dodgeY: import("../transforms/dodge").DodgeYOptions;
+        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: ((a: import("../types/index.js").RawValue, b: import("../types/index.js").RawValue) => number) | {
+            channel: string;
+            order?: "ascending" | "descending";
+        } | 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;
+        mask: string;
+        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>;
+        ondblclick: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmouseup: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmousedown: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmouseenter: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmousemove: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmouseleave: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmouseout: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmouseover: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointercancel: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerdown: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerup: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerenter: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerleave: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointermove: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerover: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerout: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondrag: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondrop: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondragstart: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondragenter: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondragleave: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondragover: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondragend: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ontouchstart: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ontouchmove: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ontouchend: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ontouchcancel: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        oncontextmenu: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onwheel: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        class: string;
+        style: string;
+        cursor: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Record<string | symbol, import("../types/index.js").RawValue>>;
+    }> & import("../types/index.js").LinkableMarkProps<Record<string | symbol, import("../types/index.js").RawValue>> & import("../types/index.js").BaseRectMarkProps<Record<string | symbol, import("../types/index.js").RawValue>> & {
+        data: Record<string | symbol, import("../types/index.js").RawValue>[];
+        x?: import("../types/index.js").ChannelAccessor<Record<string | symbol, import("../types/index.js").RawValue>>;
+        y?: import("../types/index.js").ChannelAccessor<Record<string | symbol, import("../types/index.js").RawValue>>;
+    }, "data" | "x"> & {
+        data: Datum[];
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<Datum extends DataRow> {
+    props(): ReturnType<typeof $$render<Datum>>['props'];
+    events(): ReturnType<typeof $$render<Datum>>['events'];
+    slots(): ReturnType<typeof $$render<Datum>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Datum extends DataRow>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Datum>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Datum>['props']>, ReturnType<__sveltets_Render<Datum>['events']>, ReturnType<__sveltets_Render<Datum>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<Datum>['bindings']>;
+    } & ReturnType<__sveltets_Render<Datum>['exports']>;
+    <Datum extends DataRow>(internal: unknown, props: ReturnType<__sveltets_Render<Datum>['props']> & {}): ReturnType<__sveltets_Render<Datum>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
 /** For arbitrary rectangles with fixed x position, requires band y scale */
-declare const CellY: import("svelte").Component<CellYMarkProps, {}, "">;
-type CellY = ReturnType<typeof CellY>;
+declare const CellY: $$IsomorphicComponent;
+type CellY<Datum extends DataRow> = InstanceType<typeof CellY<Datum>>;
 export default CellY;

package/dist/marks/DotX.svelte

@@ -2,12 +2,13 @@
     Creates a horizontal dot plot with x values along a single y position
 -->
 <script lang="ts" generics="Datum extends DataRow">
-    interface DotXMarkProps extends Omit<ComponentProps<typeof Dot>, 'y' | 'data'> {
+    interface DotXMarkProps extends Omit<ComponentProps<typeof Dot>, 'y' | 'x' | 'data'> {
         data: Datum[];
+        x?: ChannelAccessor<Datum>;
     }
     import Dot from './Dot.svelte';
     import { recordizeX } from '../index.js';
-    import type { DataRow } from '../types/index.js';
+    import type { ChannelAccessor, DataRow } from '../types/index.js';
     import type { ComponentProps } from 'svelte';
 
     let { data = [{} as Datum], ...options }: DotXMarkProps = $props();

package/dist/marks/DotX.svelte.d.ts

@@ -1,27 +1,27 @@
-import type { DataRow } from '../types/index.js';
+import type { ChannelAccessor, DataRow } from '../types/index.js';
 declare function $$render<Datum extends DataRow>(): {
     props: Omit<Partial<{
         filter: import("../types/index.js").ConstantAccessor<boolean, Record<string | symbol, import("../types/data").RawValue>>;
         facet: "auto" | "include" | "exclude";
-        fx: import("../types/channel").ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
-        fy: import("../types/channel").ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
+        fx: ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
+        fy: ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
         dx: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data").RawValue>>;
         dy: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data").RawValue>>;
         dodgeX: import("../transforms/dodge").DodgeXOptions;
         dodgeY: import("../transforms/dodge").DodgeYOptions;
-        fill: import("../types/channel").ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
+        fill: ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
         fillOpacity: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data").RawValue>>;
         sort: ((a: import("../types/data").RawValue, b: import("../types/data").RawValue) => number) | {
             channel: string;
             order?: "ascending" | "descending";
         } | import("../types/index.js").ConstantAccessor<import("../types/data").RawValue, Record<string | symbol, import("../types/data").RawValue>>;
-        stroke: import("../types/channel").ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
+        stroke: ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
         strokeWidth: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data").RawValue>>;
         strokeOpacity: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data").RawValue>>;
         strokeLinejoin: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, Record<string | symbol, import("../types/data").RawValue>>;
         strokeLinecap: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, Record<string | symbol, import("../types/data").RawValue>>;
         strokeMiterlimit: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data").RawValue>>;
-        opacity: import("../types/channel").ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
+        opacity: ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
         strokeDasharray: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/data").RawValue>>;
         strokeDashoffset: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data").RawValue>>;
         mixBlendMode: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, Record<string | symbol, import("../types/data").RawValue>>;
@@ -65,14 +65,15 @@ declare function $$render<Datum extends DataRow>(): {
         cursor: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Record<string | symbol, import("../types/data").RawValue>>;
     }> & import("../types/mark").LinkableMarkProps<Record<string | symbol, import("../types/data").RawValue>> & {
         data: Record<string | symbol, import("../types/data").RawValue>[];
-        x: import("../types/channel").ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
-        y: import("../types/channel").ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
-        r?: import("../types/channel").ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
-        symbol?: import("../types/channel").ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>> | import("svelte").Snippet<[number, string]>;
+        x: ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
+        y: ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
+        r?: ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
+        symbol?: ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>> | import("svelte").Snippet<[number, string]>;
         canvas?: boolean;
         dotClass?: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/data").RawValue>>;
-    }, "data" | "y"> & {
+    }, "data" | "x" | "y"> & {
         data: Datum[];
+        x?: ChannelAccessor<Datum>;
     };
     exports: {};
     bindings: "";

package/dist/marks/WaffleX.svelte

@@ -95,7 +95,7 @@
             <g class={['waffle-x', className]}>
                 <pattern {...pattern}>
                     {#if symbol}
-                        {@render symbol(rect)}
+                        {@render symbol({ ...rect, style, styleClass, datum: d.datum })}
                     {:else if hasBorderRadius}
                         <path
                             d={roundedRect(rect.x, rect.y, rect.width, rect.height, borderRadius)}

package/dist/marks/helpers/BaseAxisX.svelte

@@ -42,6 +42,7 @@
         };
         text: boolean;
         plot: PlotState;
+        class: string;
     };
 
     let {
@@ -59,6 +60,7 @@
         options,
         plot,
         title,
+        class: className = 'axis-x',
         text = true
     }: BaseAxisXProps = $props();
 
@@ -176,7 +178,7 @@
     });
 </script>
 
-<g class="axis-x">
+<g class={className}>
     {#each positionedTicks as tick, t (tick[RAW_VALUE])}
         {#if testFilter(tick, options) && !tick.hidden}
             {@const tickClass_ = resolveProp(tickClass, tick)}

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

@@ -22,6 +22,7 @@ type BaseAxisXProps = {
     };
     text: boolean;
     plot: PlotState;
+    class: string;
 };
 declare const BaseAxisX: import("svelte").Component<BaseAxisXProps, {}, "">;
 type BaseAxisX = ReturnType<typeof BaseAxisX>;

package/dist/marks/helpers/BaseAxisY.svelte

@@ -36,6 +36,7 @@
         };
         plot: PlotState;
         text: boolean | null;
+        class: string;
     };
 
     let {
@@ -54,7 +55,8 @@
         title,
         plot,
         options,
-        text = true
+        text = true,
+        class: className = 'axis-y'
     }: BaseAxisYProps = $props();
 
     const LINE_ANCHOR = {
@@ -153,7 +155,7 @@
     });
 </script>
 
-<g class="axis-y">
+<g class={className}>
     {#each positionedTicks as tick, t (tick[RAW_VALUE])}
         {#if testFilter(tick, options) && !tick.hidden}
             {@const tickClass_ = resolveProp(tickClass, tick)}

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

@@ -20,6 +20,7 @@ type BaseAxisYProps = {
     };
     plot: PlotState;
     text: boolean | null;
+    class: string;
 };
 declare const BaseAxisY: import("svelte").Component<BaseAxisYProps, {}, "">;
 type BaseAxisY = ReturnType<typeof BaseAxisY>;

package/dist/marks/helpers/Marker.svelte

@@ -74,7 +74,7 @@
     const markerColors = $derived({
         fill: 'none',
         [MARKERS[shape].color]: color,
-        ...(MARKERS[shape].bg ? { [MARKERS[shape].bg as string]: 'var(--svelteplot-bg)' } : {})
+        ...(MARKERS[shape].bg ? { [MARKERS[shape].bg as string]: 'var(--svp-bg)' } : {})
     });
 </script>
 

package/dist/transforms/bollinger.d.ts

@@ -1,4 +1,4 @@
-import type { DataRecord, TransformArg } from '../types/index.js';
+import type { TransformArg } from '../types/index.js';
 export type BollingerOptions = {
     /**
      * the window size (the window transform’s k option), an integer; defaults to 20
@@ -9,75 +9,6 @@ export type BollingerOptions = {
      */
     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): {
-    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>>;
-    dodgeX?: import("./dodge").DodgeXOptions | undefined;
-    dodgeY?: import("./dodge").DodgeYOptions | undefined;
-    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?: ((a: import("../types/index.js").RawValue, b: import("../types/index.js").RawValue) => number) | {
-        channel: string;
-        order?: "ascending" | "descending";
-    } | 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;
-    mask?: 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 | undefined;
-    style?: string | 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 bollingerX<T>(args: TransformArg<T>, options?: BollingerOptions): TransformArg<T>;
+export declare function bollingerY<T>(args: TransformArg<T>, options?: BollingerOptions): TransformArg<T>;
+export declare function bollingerDim<T>(dim: 'x' | 'y', { data, ...channels }: TransformArg<T>, options?: BollingerOptions): TransformArg<T>;

package/dist/transforms/index.d.ts

@@ -7,7 +7,7 @@ export { map, mapX, mapY } from './map.js';
 export { normalizeX, normalizeY, normalizeParallelX, normalizeParallelY } from './normalize.js';
 export { group, groupX, groupY, groupZ } from './group.js';
 export { intervalX, intervalY } from './interval.js';
-export { jitterX, jitterY } from './jitter.js';
+export { jitter, jitterX, jitterY } from './jitter.js';
 export { recordizeX, recordizeY } from './recordize.js';
 export { renameChannels, replaceChannels } from './rename.js';
 export { select, selectFirst, selectLast, selectMaxX, selectMaxY, selectMinX, selectMinY } from './select.js';

package/dist/transforms/index.js

@@ -7,7 +7,7 @@ export { map, mapX, mapY } from './map.js';
 export { normalizeX, normalizeY, normalizeParallelX, normalizeParallelY } from './normalize.js';
 export { group, groupX, groupY, groupZ } from './group.js';
 export { intervalX, intervalY } from './interval.js';
-export { jitterX, jitterY } from './jitter.js';
+export { jitter, jitterX, jitterY } from './jitter.js';
 export { recordizeX, recordizeY } from './recordize.js';
 export { renameChannels, replaceChannels } from './rename.js';
 export { select, selectFirst, selectLast, selectMaxX, selectMaxY, selectMinX, selectMinY } from './select.js';

package/dist/transforms/interval.js

@@ -12,7 +12,7 @@ function interval(dim, plot, { data, ...options }) {
         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 interval = maybeInterval(options.interval);
         const newData = data.map((row) => {
             const val = resolveChannel(dim, row, options);
             return {

package/dist/transforms/jitter.d.ts

@@ -1,17 +1,19 @@
-import type { Channels, DataRecord, TransformArg } from '../types/index.js';
+import type { TransformArg, TransformReturn } from '../types/index.js';
 type JitterOptions = {
-    type: 'uniform' | 'normal';
-    /** width for uniform jittering */
-    width: number;
-    /** standard deviation for normal jittering */
-    std: number;
     /**
      * optional random number source that produces values in range [0,1)
      * useful for testing with a deterministic source
      */
     source?: () => number;
-};
-export declare function jitterX({ data, ...channels }: TransformArg<DataRecord>, options: JitterOptions): TransformArg<DataRecord>;
-export declare function jitterY({ data, ...channels }: TransformArg<DataRecord>, options: JitterOptions): TransformArg<DataRecord>;
-export declare function jitter(channel: 'x' | 'y', data: DataRecord[], channels: Channels, options: JitterOptions): TransformArg<DataRecord>;
+} & ({
+    type: 'uniform';
+    width?: number | string;
+} | {
+    type: 'normal';
+    std?: number | string;
+});
+export declare function jitterX<T>(args: TransformArg<T>, options: JitterOptions): TransformReturn<T, 'x'>;
+export declare function jitterY<T>(args: TransformArg<T>, options: JitterOptions): TransformReturn<T, 'y'>;
+type PositionalScale = 'x' | 'x1' | 'x2' | 'y' | 'y1' | 'y2';
+export declare function jitter<T, C extends TransformArg<T>>({ data, ...channels }: C, options: Partial<Record<PositionalScale, JitterOptions>>): TransformReturn<C, T>;
 export {};

package/dist/transforms/jitter.js

@@ -2,46 +2,62 @@ import { resolveChannel } from '../helpers/resolve.js';
 import { randomUniform, randomNormal } from 'd3-random';
 import { isDate } from '../helpers/typeChecks.js';
 import { durations, parseTimeInterval } from '../helpers/time.js';
-const JITTER_X = Symbol('jitterX');
-const JITTER_Y = Symbol('jitterY');
-export function jitterX({ data, ...channels }, options) {
-    return jitter('x', data, channels, options);
+const JITTER = {
+    x: Symbol('jitterX'),
+    x1: Symbol('jitterX1'),
+    x2: Symbol('jitterX2'),
+    y: Symbol('jitterY'),
+    y1: Symbol('jitterY1'),
+    y2: Symbol('jitterY2')
+};
+export function jitterX(args, options) {
+    return jitter(args, { x: options });
 }
-export function jitterY({ data, ...channels }, options) {
-    return jitter('y', data, channels, options);
+export function jitterY(args, options) {
+    return jitter(args, { y: options });
 }
-export function jitter(channel, data, channels, options) {
-    if (channels[channel]) {
-        const type = options?.type ?? 'uniform';
-        const width = parseNumber(options?.width ?? 0.35);
-        const std = parseNumber(options?.std ?? 0.15);
+export function jitter({ data, ...channels }, options) {
+    const jitterChannels = Object.keys(options).filter((ch) => channels[ch]);
+    // if no jitter channels are defined return early
+    if (!jitterChannels.length)
+        return {
+            data,
+            ...channels
+        };
+    // construct jitter functions
+    const jitterFns = Object.fromEntries(Object.entries(options).map(([key, opts]) => {
+        opts.type = opts.type ?? 'uniform';
+        const width = opts?.type === 'uniform' ? parseNumber(opts?.width ?? 0.35) : 0;
+        const std = opts?.type === 'normal' ? parseNumber(opts?.std ?? 0.15) : 0;
         // @todo support time interval strings as width/std parameters
         // Use the provided source or default to Math.random
-        const rng = options?.source ?? Math.random;
-        const random = type === 'uniform'
+        const rng = opts?.source ?? Math.random;
+        const random = opts?.type === 'uniform'
             ? randomUniform.source(rng)(-width, width)
             : randomNormal.source(rng)(0, std);
-        const accKey = channel === 'x' ? JITTER_X : JITTER_Y;
-        return {
-            data: data.map((row) => {
+        return [key, random];
+    }));
+    return {
+        data: data.map((row) => {
+            let newRow = { ...row };
+            jitterChannels.forEach((channel) => {
                 const value = resolveChannel(channel, row, channels);
-                return {
-                    ...row,
+                const random = jitterFns[channel];
+                const accKey = JITTER[channel];
+                newRow = {
+                    ...newRow,
                     [accKey]: typeof value === 'number'
                         ? value + random()
                         : isDate(value)
                             ? new Date(value.getTime() + random())
                             : value
                 };
-            }),
-            ...channels,
-            // point channel to new accessor symbol
-            [channel]: accKey
-        };
-    }
-    return {
-        data,
-        ...channels
+            });
+            return newRow;
+        }),
+        ...channels,
+        // point the jittered channels to new accessor symbols
+        ...Object.fromEntries(jitterChannels.map((channel) => [channel, JITTER[channel]]))
     };
 }
 function parseNumber(value) {
@@ -50,7 +66,7 @@ function parseNumber(value) {
     if (typeof value === 'string') {
         try {
             const [name, period] = parseTimeInterval(value);
-            return durations.get(name) * period;
+            return (durations.get(name) ?? 0) * period;
         }
         catch (err) {
             return 0;

package/dist/transforms/map.js

@@ -2,8 +2,9 @@ import { identity } from '../helpers/index.js';
 import { count, rank } from 'd3-array';
 import { groupFacetsAndZ } from '../helpers/group.js';
 import { resolveChannel } from '../helpers/resolve.js';
+import { sort } from './sort';
 export function map(args, options) {
-    const { data, ...channels } = args;
+    const { data, ...channels } = sort(args);
     const newChannels = {};
     const newData = [];
     groupFacetsAndZ(data, channels, (groupedData) => {

package/dist/transforms/recordize.d.ts

@@ -1,4 +1,4 @@
-import type { TransformArgsRow, TransformArgsRecord } from '../types/index.js';
+import type { TransformArgsRow, TransformArgsRecord, DataRecord, DataRow } from '../types/index.js';
 import { INDEX } from '../constants';
 export declare const X: unique symbol;
 export declare const Y: unique symbol;
@@ -6,12 +6,12 @@ export declare const RAW_VALUE: unique symbol;
 export declare function indexData<T extends object>(data: T[]): (T & {
     [INDEX]: number;
 })[];
-export declare function recordizeX<T>({ data, ...channels }: TransformArgsRow<T>, { withIndex }?: {
+export declare function recordizeX<T>({ data, ...channels }: TransformArgsRow<DataRow>, { withIndex }?: {
     withIndex: boolean;
-}): TransformArgsRecord<T>;
-export declare function recordizeY<T>({ data, ...channels }: TransformArgsRow<T>, { withIndex }?: {
+}): TransformArgsRecord<DataRecord>;
+export declare function recordizeY<T>({ data, ...channels }: TransformArgsRow<DataRow>, { withIndex }?: {
     withIndex: boolean;
-}): TransformArgsRecord<T>;
+}): TransformArgsRecord<DataRecord>;
 /**
  * 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

package/dist/types/data.d.ts

@@ -1,5 +1,5 @@
 import type { ScaledChannelName, ScaledChannelType } from './channel.js';
-export type RawValue = number | Date | boolean | string | symbol | object;
+export type RawValue = number | Date | boolean | string | symbol | object | null;
 export type DataRecord<T = Record<string | symbol, RawValue>> = T;
 export type ResolvedDataRecord<T = Record<string | symbol, RawValue>> = Partial<Record<ScaledChannelName, any>> & {
     datum: DataRecord<T>;

package/dist/types/index.d.ts

@@ -31,12 +31,13 @@ export type TransformArg<T> = Channels<T> & BaseMarkProps<T> & {
 export type MapArg<T> = Channels<T> & {
     data: T[];
 };
-export type TransformArgsRow<T extends RawValue & object> = Partial<Channels<T>> & {
+export type TransformArgsRow<T extends RawValue | object> = Partial<Channels<T>> & {
     data: T[];
 };
 export type TransformArgsRecord<T extends object> = Partial<Channels<T>> & {
     data: T[];
 };
+export type TransformReturn<C extends TransformArg<T>, T> = C & Required<Pick<Channels<T>, 'data'>>;
 export type AutoMarginStores = {
     autoMarginTop: Writable<Map<string, number>>;
     autoMarginLeft: Writable<Map<string, number>>;

package/dist/types/mark.d.ts

@@ -11,7 +11,8 @@ export type MarkStyleProps = 'strokeDasharray' | 'strokeLinejoin' | 'strokeLinec
 import type { MouseEventHandler } from 'svelte/elements';
 import type { ChannelAccessor, ConstantAccessor, DataRecord, RawValue } from './index.js';
 import type * as CSS from 'csstype';
-import type { ScaledChannelName, ScaleName } from './scale.js';
+import type { ScaledChannelName } from './channel.js';
+import type { ScaleName } from './scale.js';
 import type { DodgeXOptions, DodgeYOptions } from '../transforms/dodge.js';
 export type BaseMarkProps<T> = Partial<{
     /**