svelteplot 0.3.0 → 0.3.2-pr-113.0

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

@@ -1,27 +1,99 @@
-export type AxisXMarkProps = Omit<BaseMarkProps, 'fill' | 'fillOpacity' | 'paintOrder' | 'title' | 'href' | 'target'> & {
-    data?: RawValue[];
-    automatic?: boolean;
-    title?: string;
-    anchor?: 'top' | 'bottom';
-    interval?: string | number;
-    facetAnchor?: 'auto' | 'top-empty' | 'bottom-empty' | 'top' | 'bottom';
-    labelAnchor?: 'auto' | 'left' | 'center' | 'right';
-    tickSize?: number;
-    tickFontSize?: ConstantAccessor<number>;
-    tickPadding?: number;
-    tickFormat?: 'auto' | Intl.DateTimeFormatOptions | Intl.NumberFormatOptions | ((d: RawValue) => string);
-    tickClass?: ConstantAccessor<string>;
-    /** ticks is a shorthand for defining data, tickCount or interval */
-    ticks?: number | string | RawValue[];
-    /** set to false or null to disable tick labels */
-    text: boolean | null;
-    /** approximate number of ticks to be generated */
-    tickCount?: number;
-    /** approximate number of pixels between generated ticks */
-    tickSpacing?: number;
-};
-import type { BaseMarkProps, RawValue, ConstantAccessor } from '../types.js';
+import type { RawValue, ConstantAccessor } from '../types/index.js';
+declare class __sveltets_Render<Datum extends RawValue> {
+    props(): Omit<Partial<{
+        filter?: ConstantAccessor<boolean, Datum>;
+        facet?: "auto" | "include" | "exclude";
+        fx: import("../types/channel").ChannelAccessor<Datum>;
+        fy: import("../types/channel").ChannelAccessor<Datum>;
+        dx: ConstantAccessor<number, Datum>;
+        dy: ConstantAccessor<number, Datum>;
+        fill: import("../types/channel").ChannelAccessor<Datum>;
+        fillOpacity: ConstantAccessor<number, Datum>;
+        sort: {
+            channel: string;
+            order?: "ascending" | "descending";
+        } | ((a: RawValue, b: RawValue) => number) | ConstantAccessor<RawValue, Datum>;
+        stroke: import("../types/channel").ChannelAccessor<Datum>;
+        strokeWidth: ConstantAccessor<number, Datum>;
+        strokeOpacity: ConstantAccessor<number, Datum>;
+        strokeLinejoin: ConstantAccessor<import("csstype").Property.StrokeLinejoin, Datum>;
+        strokeLinecap: ConstantAccessor<import("csstype").Property.StrokeLinecap, Datum>;
+        strokeMiterlimit: ConstantAccessor<number, Datum>;
+        opacity: import("../types/channel").ChannelAccessor<Datum>;
+        strokeDasharray: ConstantAccessor<string, Datum>;
+        strokeDashoffset: ConstantAccessor<number, Datum>;
+        mixBlendMode: ConstantAccessor<import("csstype").Property.MixBlendMode, Datum>;
+        clipPath: string;
+        imageFilter: ConstantAccessor<string, Datum>;
+        shapeRendering: ConstantAccessor<import("csstype").Property.ShapeRendering, Datum>;
+        paintOrder: 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: ConstantAccessor<import("csstype").Property.Cursor, Datum>;
+    }>, "fill" | "fillOpacity" | "href" | "target" | "title" | "paintOrder"> & {
+        data?: Datum[] | undefined;
+        automatic?: boolean;
+        title?: string;
+        anchor?: "top" | "bottom";
+        interval?: string | number;
+        facetAnchor?: "auto" | "top-empty" | "bottom-empty" | "top" | "bottom";
+        labelAnchor?: "auto" | "left" | "center" | "right";
+        tickSize?: number;
+        tickFontSize?: ConstantAccessor<number, Datum>;
+        tickPadding?: number;
+        tickFormat?: "auto" | Intl.NumberFormatOptions | Intl.DateTimeFormatOptions | ((d: RawValue) => string) | undefined;
+        tickClass?: ConstantAccessor<string, Datum>;
+        /** ticks is a shorthand for defining data, tickCount or interval */
+        ticks?: string | number | Datum[] | undefined;
+        /** set to false or null to disable tick labels */
+        text: boolean | null;
+        /** approximate number of ticks to be generated */
+        tickCount?: number;
+        /** approximate number of pixels between generated ticks */
+        tickSpacing?: number;
+    };
+    events(): {};
+    slots(): {};
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Datum extends RawValue>(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 RawValue>(internal: unknown, props: ReturnType<__sveltets_Render<Datum>['props']> & {}): ReturnType<__sveltets_Render<Datum>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
 /** Renders a horizontal axis with labels and tick marks */
-declare const AxisX: import("svelte").Component<AxisXMarkProps, {}, "">;
-type AxisX = ReturnType<typeof AxisX>;
+declare const AxisX: $$IsomorphicComponent;
+type AxisX<Datum extends RawValue> = InstanceType<typeof AxisX<Datum>>;
 export default AxisX;

package/dist/marks/AxisY.svelte

@@ -1,13 +1,29 @@
 <!-- @component
     Renders a vertical axis with labels and tick marks
 -->
-<script module lang="ts">
-    import type { XOR } from 'ts-essentials';
-    export type AxisYMarkProps = Omit<
+<script lang="ts" generics="Datum extends RawValue">
+    import { getContext } from 'svelte';
+    import BaseAxisY from './helpers/BaseAxisY.svelte';
+    import Mark from '../Mark.svelte';
+    import type {
+        PlotContext,
         BaseMarkProps,
-        'fill' | 'fillOpacity' | 'paintOrder' | 'title' | 'href' | 'target'
-    > & {
-        data?: RawValue[];
+        RawValue,
+        FacetContext,
+        PlotDefaults,
+        ChannelName,
+        ConstantAccessor
+    } from '../types/index.js';
+    import autoTimeFormat from '../helpers/autoTimeFormat.js';
+    import { autoTicks } from '../helpers/autoTicks.js';
+    import { resolveScaledStyles } from '../helpers/resolve.js';
+
+    interface AxisYMarkProps
+        extends Omit<
+            BaseMarkProps<Datum>,
+            'fill' | 'fillOpacity' | 'paintOrder' | 'title' | 'href' | 'target'
+        > {
+        data?: Datum[];
         automatic?: boolean;
         title?: string;
         anchor?: 'left' | 'right';
@@ -16,41 +32,23 @@
         interval?: string | number;
         labelAnchor?: 'auto' | 'left' | 'center' | 'right';
         tickSize?: number;
-        tickFontSize?: ConstantAccessor<number>;
+        tickFontSize?: ConstantAccessor<number, Datum>;
         tickPadding?: number;
         tickFormat?:
             | 'auto'
             | Intl.DateTimeFormatOptions
             | Intl.NumberFormatOptions
             | ((d: RawValue) => string);
-        tickClass?: ConstantAccessor<string>;
+        tickClass?: ConstantAccessor<string, Datum>;
         /** ticks is a shorthand for defining data, tickCount or interval */
-        ticks?: number | string | RawValue[];
+        ticks?: number | string | Datum[];
         /** set to false or null to disable tick labels */
         text: boolean | null;
         /** approximate number of ticks to be generated */
         tickCount?: number;
         /** approximate number of pixels between generated ticks */
         tickSpacing?: number;
-    };
-</script>
-
-<script lang="ts">
-    import { getContext } from 'svelte';
-    import BaseAxisY from './helpers/BaseAxisY.svelte';
-    import Mark from '../Mark.svelte';
-    import type {
-        PlotContext,
-        BaseMarkProps,
-        RawValue,
-        FacetContext,
-        PlotDefaults,
-        ChannelName
-    } from '../types.js';
-    import autoTimeFormat from '../helpers/autoTimeFormat.js';
-    import type { ConstantAccessor } from '../types.js';
-    import { autoTicks } from '../helpers/autoTicks.js';
-    import { resolveScaledStyles } from '../helpers/resolve.js';
+    }
 
     let markProps: AxisYMarkProps = $props();
 
@@ -68,7 +66,8 @@
         data = Array.isArray(magicTicks) ? magicTicks : [],
         automatic = false,
         title,
-        anchor,
+        anchor = 'left',
+        class: className,
         facetAnchor = 'auto',
         interval = typeof magicTicks === 'string' ? magicTicks : undefined,
         lineAnchor = 'center',
@@ -189,22 +188,23 @@
     {/if}
     {#if showAxis}
         <BaseAxisY
-            scaleFn={plot.scales.y.fn}
-            scaleType={plot.scales.y.type}
-            tickFormat={useTickFormat}
-            {ticks}
-            marginLeft={plot.options.marginLeft}
-            width={plot.facetWidth}
             {anchor}
+            {className}
             {lineAnchor}
-            {tickSize}
-            {tickPadding}
-            {tickFontSize}
-            {tickClass}
             {options}
+            {plot}
             {text}
+            {tickClass}
+            {tickFontSize}
+            {tickPadding}
+            {ticks}
+            {tickSize}
+            marginLeft={plot.options.marginLeft}
+            scaleFn={plot.scales.y.fn}
+            scaleType={plot.scales.y.type}
+            tickFormat={useTickFormat}
             title={useTitle}
-            {plot} />
+            width={plot.facetWidth} />
     {/if}
 </Mark>
 

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

@@ -1,29 +1,100 @@
-export type AxisYMarkProps = Omit<BaseMarkProps, 'fill' | 'fillOpacity' | 'paintOrder' | 'title' | 'href' | 'target'> & {
-    data?: RawValue[];
-    automatic?: boolean;
-    title?: string;
-    anchor?: 'left' | 'right';
-    facetAnchor?: 'auto' | 'left' | 'right' | 'left-empty' | 'right-empty';
-    lineAnchor?: 'top' | 'center' | 'bottom';
-    interval?: string | number;
-    labelAnchor?: 'auto' | 'left' | 'center' | 'right';
-    tickSize?: number;
-    tickFontSize?: ConstantAccessor<number>;
-    tickPadding?: number;
-    tickFormat?: 'auto' | Intl.DateTimeFormatOptions | Intl.NumberFormatOptions | ((d: RawValue) => string);
-    tickClass?: ConstantAccessor<string>;
-    /** ticks is a shorthand for defining data, tickCount or interval */
-    ticks?: number | string | RawValue[];
-    /** set to false or null to disable tick labels */
-    text: boolean | null;
-    /** approximate number of ticks to be generated */
-    tickCount?: number;
-    /** approximate number of pixels between generated ticks */
-    tickSpacing?: number;
-};
-import type { BaseMarkProps, RawValue } from '../types.js';
-import type { ConstantAccessor } from '../types.js';
+import type { RawValue, ConstantAccessor } from '../types/index.js';
+declare class __sveltets_Render<Datum extends RawValue> {
+    props(): Omit<Partial<{
+        filter?: ConstantAccessor<boolean, Datum>;
+        facet?: "auto" | "include" | "exclude";
+        fx: import("../types/channel").ChannelAccessor<Datum>;
+        fy: import("../types/channel").ChannelAccessor<Datum>;
+        dx: ConstantAccessor<number, Datum>;
+        dy: ConstantAccessor<number, Datum>;
+        fill: import("../types/channel").ChannelAccessor<Datum>;
+        fillOpacity: ConstantAccessor<number, Datum>;
+        sort: {
+            channel: string;
+            order?: "ascending" | "descending";
+        } | ((a: RawValue, b: RawValue) => number) | ConstantAccessor<RawValue, Datum>;
+        stroke: import("../types/channel").ChannelAccessor<Datum>;
+        strokeWidth: ConstantAccessor<number, Datum>;
+        strokeOpacity: ConstantAccessor<number, Datum>;
+        strokeLinejoin: ConstantAccessor<import("csstype").Property.StrokeLinejoin, Datum>;
+        strokeLinecap: ConstantAccessor<import("csstype").Property.StrokeLinecap, Datum>;
+        strokeMiterlimit: ConstantAccessor<number, Datum>;
+        opacity: import("../types/channel").ChannelAccessor<Datum>;
+        strokeDasharray: ConstantAccessor<string, Datum>;
+        strokeDashoffset: ConstantAccessor<number, Datum>;
+        mixBlendMode: ConstantAccessor<import("csstype").Property.MixBlendMode, Datum>;
+        clipPath: string;
+        imageFilter: ConstantAccessor<string, Datum>;
+        shapeRendering: ConstantAccessor<import("csstype").Property.ShapeRendering, Datum>;
+        paintOrder: 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: ConstantAccessor<import("csstype").Property.Cursor, Datum>;
+    }>, "fill" | "fillOpacity" | "href" | "target" | "title" | "paintOrder"> & {
+        data?: Datum[] | undefined;
+        automatic?: boolean;
+        title?: string;
+        anchor?: "left" | "right";
+        facetAnchor?: "auto" | "left" | "right" | "left-empty" | "right-empty";
+        lineAnchor?: "top" | "center" | "bottom";
+        interval?: string | number;
+        labelAnchor?: "auto" | "left" | "center" | "right";
+        tickSize?: number;
+        tickFontSize?: ConstantAccessor<number, Datum>;
+        tickPadding?: number;
+        tickFormat?: "auto" | Intl.NumberFormatOptions | Intl.DateTimeFormatOptions | ((d: RawValue) => string) | undefined;
+        tickClass?: ConstantAccessor<string, Datum>;
+        /** ticks is a shorthand for defining data, tickCount or interval */
+        ticks?: string | number | Datum[] | undefined;
+        /** set to false or null to disable tick labels */
+        text: boolean | null;
+        /** approximate number of ticks to be generated */
+        tickCount?: number;
+        /** approximate number of pixels between generated ticks */
+        tickSpacing?: number;
+    };
+    events(): {};
+    slots(): {};
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Datum extends RawValue>(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 RawValue>(internal: unknown, props: ReturnType<__sveltets_Render<Datum>['props']> & {}): ReturnType<__sveltets_Render<Datum>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
 /** Renders a vertical axis with labels and tick marks */
-declare const AxisY: import("svelte").Component<AxisYMarkProps, {}, "">;
-type AxisY = ReturnType<typeof AxisY>;
+declare const AxisY: $$IsomorphicComponent;
+type AxisY<Datum extends RawValue> = InstanceType<typeof AxisY<Datum>>;
 export default AxisY;

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());