svelteplot 0.3.4 → 0.3.5-pr-121.1

package/dist/marks/BarX.svelte

@@ -2,42 +2,40 @@
     @component
     For horizontal bar charts using a band scale as y axis
 -->
-<script module lang="ts">
-    import type {
-        PlotContext,
-        BaseMarkProps,
-        BaseRectMarkProps,
-        ChannelAccessor,
-        LinkableMarkProps,
-        PlotDefaults
-    } from '../types.js';
-
-    export type BarXMarkProps = BaseMarkProps &
-        LinkableMarkProps &
-        BaseRectMarkProps & {
-            data: DataRow[];
-            x?: ChannelAccessor;
-            x1?: ChannelAccessor;
-            x2?: ChannelAccessor;
-            y?: ChannelAccessor;
-            stack?: StackOptions;
-            /**
-             * Converts x into x1/x2 ranges based on the provided interval. Disables the
-             * implicit stacking
-             */
-            interval?: number | string;
-        };
-</script>
+<script lang="ts" generics="Datum extends DataRow">
+    interface BarXMarkProps
+        extends BaseMarkProps<Datum>,
+            LinkableMarkProps<Datum>,
+            BaseRectMarkProps<Datum> {
+        data: Datum[];
+        x?: ChannelAccessor<Datum>;
+        x1?: ChannelAccessor<Datum>;
+        x2?: ChannelAccessor<Datum>;
+        y?: ChannelAccessor<Datum>;
+        stack?: StackOptions;
+        /**
+         * Converts x into x1/x2 ranges based on the provided interval. Disables the
+         * implicit stacking
+         */
+        interval?: number | string;
+    }
 
-<script lang="ts">
     import Mark from '../Mark.svelte';
     import { getContext } from 'svelte';
-    import { stackX, recordizeX, intervalX, sort } from '../index.js';
+    import { stackX, recordizeX, intervalX, sort } from '..';
 
     import type { StackOptions } from '../transforms/stack.js';
-    import type { DataRow } from '../types.js';
+    import type { DataRow } from '../types/index.js';
     import GroupMultiple from './helpers/GroupMultiple.svelte';
     import RectPath from './helpers/RectPath.svelte';
+    import type {
+        PlotContext,
+        BaseMarkProps,
+        BaseRectMarkProps,
+        ChannelAccessor,
+        LinkableMarkProps,
+        PlotDefaults
+    } from '../types/index.js';
 
     const DEFAULTS = {
         fill: 'currentColor',
@@ -48,7 +46,7 @@
     let markProps: BarXMarkProps = $props();
 
     const {
-        data = [{}],
+        data = [{} as Datum],
         class: className = null,
         stack,
         ...options

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

@@ -1,20 +1,92 @@
-import type { BaseMarkProps, BaseRectMarkProps, ChannelAccessor, LinkableMarkProps } from '../types.js';
-export type BarXMarkProps = BaseMarkProps & LinkableMarkProps & BaseRectMarkProps & {
-    data: DataRow[];
-    x?: ChannelAccessor;
-    x1?: ChannelAccessor;
-    x2?: ChannelAccessor;
-    y?: ChannelAccessor;
-    stack?: StackOptions;
-    /**
-     * Converts x into x1/x2 ranges based on the provided interval. Disables the
-     * implicit stacking
-     */
-    interval?: number | string;
-};
 import type { StackOptions } from '../transforms/stack.js';
-import type { DataRow } from '../types.js';
+import type { DataRow } from '../types/index.js';
+import type { BaseRectMarkProps, ChannelAccessor, LinkableMarkProps } from '../types/index.js';
+declare class __sveltets_Render<Datum extends DataRow> {
+    props(): Partial<{
+        filter?: import("../types/index.js").ConstantAccessor<boolean, Datum>;
+        facet?: "auto" | "include" | "exclude";
+        fx: ChannelAccessor<Datum>;
+        fy: ChannelAccessor<Datum>;
+        dx: import("../types/index.js").ConstantAccessor<number, Datum>;
+        dy: import("../types/index.js").ConstantAccessor<number, Datum>;
+        fill: ChannelAccessor<Datum>;
+        fillOpacity: import("../types/index.js").ConstantAccessor<number, Datum>;
+        sort: {
+            channel: string;
+            order?: "ascending" | "descending";
+        } | ((a: import("../types/data").RawValue, b: import("../types/data").RawValue) => number) | import("../types/index.js").ConstantAccessor<import("../types/data").RawValue, Datum>;
+        stroke: 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: 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").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 | null;
+        cursor: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Datum>;
+    }> & LinkableMarkProps<Datum> & BaseRectMarkProps<Datum> & {
+        data: Datum[];
+        x?: ChannelAccessor<Datum>;
+        x1?: ChannelAccessor<Datum>;
+        x2?: ChannelAccessor<Datum>;
+        y?: ChannelAccessor<Datum>;
+        stack?: StackOptions;
+        /**
+         * Converts x into x1/x2 ranges based on the provided interval. Disables the
+         * implicit stacking
+         */
+        interval?: number | string;
+    };
+    events(): {};
+    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 horizontal bar charts using a band scale as y axis */
-declare const BarX: import("svelte").Component<BarXMarkProps, {}, "">;
-type BarX = ReturnType<typeof BarX>;
+declare const BarX: $$IsomorphicComponent;
+type BarX<Datum extends DataRow> = InstanceType<typeof BarX<Datum>>;
 export default BarX;

package/dist/marks/BarY.svelte

@@ -2,41 +2,41 @@
     @component
     For vertical column charts using a band scale as x axis
 -->
-<script module lang="ts">
-    import type {
-        PlotContext,
-        BaseMarkProps,
-        BaseRectMarkProps,
-        ChannelAccessor,
-        DataRow,
-        PlotDefaults
-    } from '../types.js';
 
-    export type BarYMarkProps = BaseMarkProps &
-        LinkableMarkProps &
-        BaseRectMarkProps & {
-            data: DataRow[];
-            x?: ChannelAccessor;
-            y?: ChannelAccessor;
-            y1?: ChannelAccessor;
-            y2?: ChannelAccessor;
-            stack?: StackOptions;
-            /**
-             * Converts y into y1/y2 ranges based on the provided interval. Disables the
-             * implicit stacking
-             */
-            interval?: number | string;
-        };
-</script>
+<script lang="ts" generics="Datum extends DataRow">
+    interface BarYMarkProps
+        extends BaseMarkProps<Datum>,
+            LinkableMarkProps<Datum>,
+            BaseRectMarkProps<Datum> {
+        data: Datum[];
+        x?: ChannelAccessor<Datum>;
+        y?: ChannelAccessor<Datum>;
+        y1?: ChannelAccessor<Datum>;
+        y2?: ChannelAccessor<Datum>;
+        stack?: StackOptions;
+        /**
+         * Converts y into y1/y2 ranges based on the provided interval. Disables the
+         * implicit stacking
+         */
+        interval?: number | string;
+    }
 
-<script lang="ts">
     import Mark from '../Mark.svelte';
     import { getContext } from 'svelte';
-    import { intervalY, stackY, recordizeY, sort } from '../index.js';
+    import { intervalY, stackY, recordizeY, sort } from '..';
 
     import type { StackOptions } from '../transforms/stack.js';
     import GroupMultiple from './helpers/GroupMultiple.svelte';
     import RectPath from './helpers/RectPath.svelte';
+    import type {
+        PlotContext,
+        BaseMarkProps,
+        BaseRectMarkProps,
+        ChannelAccessor,
+        DataRow,
+        PlotDefaults,
+        LinkableMarkProps
+    } from '../types/index.js';
 
     const { getPlotState } = getContext<PlotContext>('svelteplot');
     const plot = $derived(getPlotState());

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

@@ -1,19 +1,91 @@
-import type { BaseMarkProps, BaseRectMarkProps, ChannelAccessor, DataRow } from '../types.js';
-export type BarYMarkProps = BaseMarkProps & LinkableMarkProps & BaseRectMarkProps & {
-    data: DataRow[];
-    x?: ChannelAccessor;
-    y?: ChannelAccessor;
-    y1?: ChannelAccessor;
-    y2?: ChannelAccessor;
-    stack?: StackOptions;
-    /**
-     * Converts y into y1/y2 ranges based on the provided interval. Disables the
-     * implicit stacking
-     */
-    interval?: number | string;
-};
 import type { StackOptions } from '../transforms/stack.js';
+import type { BaseRectMarkProps, ChannelAccessor, DataRow, LinkableMarkProps } from '../types/index.js';
+declare class __sveltets_Render<Datum extends DataRow> {
+    props(): Partial<{
+        filter?: import("../types/index.js").ConstantAccessor<boolean, Datum>;
+        facet?: "auto" | "include" | "exclude";
+        fx: ChannelAccessor<Datum>;
+        fy: ChannelAccessor<Datum>;
+        dx: import("../types/index.js").ConstantAccessor<number, Datum>;
+        dy: import("../types/index.js").ConstantAccessor<number, Datum>;
+        fill: ChannelAccessor<Datum>;
+        fillOpacity: import("../types/index.js").ConstantAccessor<number, Datum>;
+        sort: {
+            channel: string;
+            order?: "ascending" | "descending";
+        } | ((a: import("../types/data").RawValue, b: import("../types/data").RawValue) => number) | import("../types/index.js").ConstantAccessor<import("../types/data").RawValue, Datum>;
+        stroke: 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: 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").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 | null;
+        cursor: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Datum>;
+    }> & LinkableMarkProps<Datum> & BaseRectMarkProps<Datum> & {
+        data: Datum[];
+        x?: ChannelAccessor<Datum>;
+        y?: ChannelAccessor<Datum>;
+        y1?: ChannelAccessor<Datum>;
+        y2?: ChannelAccessor<Datum>;
+        stack?: StackOptions;
+        /**
+         * Converts y into y1/y2 ranges based on the provided interval. Disables the
+         * implicit stacking
+         */
+        interval?: number | string;
+    };
+    events(): {};
+    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 vertical column charts using a band scale as x axis */
-declare const BarY: import("svelte").Component<any, {}, "">;
-type BarY = ReturnType<typeof BarY>;
+declare const BarY: $$IsomorphicComponent;
+type BarY<Datum extends DataRow> = InstanceType<typeof BarY<Datum>>;
 export default BarY;

package/dist/marks/BollingerX.svelte

@@ -2,26 +2,29 @@
     @component
     line representing a moving average and an area representing volatility as a band
 -->
-<script module lang="ts">
-    export type BollingerXMarkProps = BaseMarkProps & {
-        data: DataRow[];
-        x?: ChannelAccessor;
-        y?: ChannelAccessor;
+<script lang="ts" generics="Datum extends DataRecord">
+    import { Area, Line, bollingerX, recordizeX } from '..';
+    import type {
+        BaseMarkProps,
+        ChannelAccessor,
+        DataRecord,
+        TransformArg
+    } from '../types/index.js';
+    import { pick } from 'es-toolkit';
+
+    interface BollingerXMarkProps extends BaseMarkProps<Datum> {
+        data: Datum[];
+        x?: ChannelAccessor<Datum>;
+        y?: ChannelAccessor<Datum>;
         /**
-         * the window size (the window transform’s k option), an integer; defaults to 20
+         * 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;
-    };
-</script>
-
-<script lang="ts">
-    import { Area, Line, bollingerX, recordizeX } from '../index.js';
-    import type { BaseMarkProps, ChannelAccessor, DataRow } from '../types.js';
-    import { pick } from 'es-toolkit';
+    }
 
     let {
         data,
@@ -31,7 +34,9 @@
         ...options
     }: BollingerXMarkProps = $props();
 
-    let args = $derived(bollingerX(recordizeX({ data, ...options }), { n, k }));
+    let args = $derived(
+        bollingerX(recordizeX({ data, ...options } as TransformArg<DataRecord>), { n, k })
+    );
 </script>
 
 <g class="bollinger {className || ''}">
@@ -46,7 +51,7 @@
             y1: '__x',
             x1: '__lo',
             x2: '__hi',
-            fillOpacity: 0.2,
-            ...pick(args, ['data', 'fill', 'fillOpacity', 'opacity'])
+            ...pick(args, ['data', 'fill', 'fillOpacity', 'opacity']),
+            fillOpacity: 0.2
         }} />
 </g>

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

@@ -1,18 +1,19 @@
-export type BollingerXMarkProps = BaseMarkProps & {
-    data: DataRow[];
-    x?: ChannelAccessor;
-    y?: ChannelAccessor;
-    /**
-     * 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;
-};
-import type { BaseMarkProps, ChannelAccessor, DataRow } from '../types.js';
+import type { DataRecord } from '../types/index.js';
+declare class __sveltets_Render<Datum extends DataRecord> {
+    props(): any;
+    events(): {};
+    slots(): {};
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Datum extends DataRecord>(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 DataRecord>(internal: unknown, props: ReturnType<__sveltets_Render<Datum>['props']> & {}): ReturnType<__sveltets_Render<Datum>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
 /** line representing a moving average and an area representing volatility as a band */
-declare const BollingerX: import("svelte").Component<BollingerXMarkProps, {}, "">;
-type BollingerX = ReturnType<typeof BollingerX>;
+declare const BollingerX: $$IsomorphicComponent;
+type BollingerX<Datum extends DataRecord> = InstanceType<typeof BollingerX<Datum>>;
 export default BollingerX;

package/dist/marks/BollingerY.svelte

@@ -2,30 +2,35 @@
     @component
     line representing a moving average and an area representing volatility as a band
 -->
-<script module lang="ts">
-    export type BollingerYMarkProps = BaseMarkProps & {
-        data: DataRow[];
-        x?: ChannelAccessor;
-        y?: ChannelAccessor;
+<script lang="ts" generics="Datum extends DataRecord">
+    import { Area, Line, bollingerY, recordizeY } from '..';
+    import type {
+        BaseMarkProps,
+        ChannelAccessor,
+        DataRecord,
+        TransformArg
+    } from '../types/index.js';
+    import { pick } from 'es-toolkit';
+
+    interface BollingerYMarkProps extends BaseMarkProps<Datum> {
+        data: Datum[];
+        x?: ChannelAccessor<Datum>;
+        y?: ChannelAccessor<Datum>;
         /**
-         * the window size (the window transform’s k option), an integer; defaults to 20
+         * 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;
-    };
-</script>
-
-<script lang="ts">
-    import { Area, Line, bollingerY, recordizeY } from '../index.js';
-    import type { BaseMarkProps, ChannelAccessor, DataRow } from '../types.js';
-    import { pick } from 'es-toolkit';
+    }
 
     let { data, n = 20, k = 2, class: className, ...options }: BollingerYMarkProps = $props();
 
-    const args = $derived(bollingerY(recordizeY({ data, ...options }), { n, k }));
+    const args = $derived(
+        bollingerY(recordizeY({ data, ...options } as TransformArg<DataRecord>), { n, k })
+    );
 </script>
 
 <g class="bollinger {className || ''}">
@@ -35,7 +40,7 @@
             x1: '__x',
             y1: '__lo',
             y2: '__hi',
-            fillOpacity: 0.2,
-            ...pick(args, ['data', 'fill', 'fillOpacity', 'opacity'])
+            ...pick(args, ['data', 'fill', 'fillOpacity', 'opacity']),
+            fillOpacity: 0.2
         }} />
 </g>

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

@@ -1,18 +1,19 @@
-export type BollingerYMarkProps = BaseMarkProps & {
-    data: DataRow[];
-    x?: ChannelAccessor;
-    y?: ChannelAccessor;
-    /**
-     * 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;
-};
-import type { BaseMarkProps, ChannelAccessor, DataRow } from '../types.js';
+import type { DataRecord } from '../types/index.js';
+declare class __sveltets_Render<Datum extends DataRecord> {
+    props(): any;
+    events(): {};
+    slots(): {};
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Datum extends DataRecord>(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 DataRecord>(internal: unknown, props: ReturnType<__sveltets_Render<Datum>['props']> & {}): ReturnType<__sveltets_Render<Datum>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
 /** line representing a moving average and an area representing volatility as a band */
-declare const BollingerY: import("svelte").Component<BollingerYMarkProps, {}, "">;
-type BollingerY = ReturnType<typeof BollingerY>;
+declare const BollingerY: $$IsomorphicComponent;
+type BollingerY<Datum extends DataRecord> = InstanceType<typeof BollingerY<Datum>>;
 export default BollingerY;

package/dist/marks/BoxX.svelte

@@ -1,17 +1,15 @@
 <!-- @component
     Creates a horizontal box plot for visualizing data distribution with quartiles and outliers
 -->
-<script module lang="ts">
-    export type BoxXMarkProps = BoxYMarkProps;
-</script>
 
 <script lang="ts">
+    interface BoxXMarkProps extends ComponentProps<typeof BoxY> {}
     import GroupMultiple from './helpers/GroupMultiple.svelte';
-    import type { BoxYMarkProps } from './BoxY.svelte';
-    import { BarX, TickX, RuleY, Dot, groupY } from '../index.js';
+    import { BarX, TickX, RuleY, Dot, groupY } from '..';
     import { resolveChannel } from '../helpers/resolve.js';
-    import { getContext } from 'svelte';
-    import type { PlotDefaults } from '../types.js';
+    import { getContext, type ComponentProps } from 'svelte';
+    import type { PlotDefaults } from '../types/index.js';
+    import type BoxY from './BoxY.svelte';
 
     let markProps: BoxXMarkProps = $props();
     const DEFAULTS = {

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

@@ -1,6 +1,8 @@
-export type BoxXMarkProps = BoxYMarkProps;
-import type { BoxYMarkProps } from './BoxY.svelte';
+import { type ComponentProps } from 'svelte';
+import type BoxY from './BoxY.svelte';
+interface BoxXMarkProps extends ComponentProps<typeof BoxY> {
+}
 /** Creates a horizontal box plot for visualizing data distribution with quartiles and outliers */
-declare const BoxX: import("svelte").Component<BoxYMarkProps, {}, "">;
+declare const BoxX: import("svelte").Component<BoxXMarkProps, {}, "">;
 type BoxX = ReturnType<typeof BoxX>;
 export default BoxX;