svelteplot 0.3.4 → 0.3.5-pr-121.1

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

@@ -1,9 +1,81 @@
-export type GridXMarkProps = Omit<BaseMarkProps, 'fill' | 'fillOpacity'> & {
-    data?: RawValue[];
-    automatic?: boolean;
-};
-import type { BaseMarkProps, RawValue } from '../types.js';
+import type { RawValue } from '../types/index.js';
+declare class __sveltets_Render<Datum = RawValue> {
+    props(): Omit<Partial<{
+        filter?: import("../types/index.js").ConstantAccessor<boolean, Datum>;
+        facet?: "auto" | "include" | "exclude";
+        fx: import("../types/channel").ChannelAccessor<Datum>;
+        fy: import("../types/channel").ChannelAccessor<Datum>;
+        dx: import("../types/index.js").ConstantAccessor<number, Datum>;
+        dy: import("../types/index.js").ConstantAccessor<number, Datum>;
+        fill: import("../types/channel").ChannelAccessor<Datum>;
+        fillOpacity: import("../types/index.js").ConstantAccessor<number, Datum>;
+        sort: {
+            channel: string;
+            order?: "ascending" | "descending";
+        } | ((a: RawValue, b: RawValue) => number) | import("../types/index.js").ConstantAccessor<RawValue, Datum>;
+        stroke: import("../types/channel").ChannelAccessor<Datum>;
+        strokeWidth: import("../types/index.js").ConstantAccessor<number, Datum>;
+        strokeOpacity: import("../types/index.js").ConstantAccessor<number, Datum>;
+        strokeLinejoin: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, Datum>;
+        strokeLinecap: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, Datum>;
+        strokeMiterlimit: import("../types/index.js").ConstantAccessor<number, Datum>;
+        opacity: import("../types/channel").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>;
+    }>, "fill" | "fillOpacity"> & {
+        data?: Datum[] | undefined;
+        automatic?: boolean;
+    };
+    events(): {};
+    slots(): {};
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Datum = 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 = RawValue>(internal: unknown, props: ReturnType<__sveltets_Render<Datum>['props']> & {}): ReturnType<__sveltets_Render<Datum>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
 /** Renders vertical gridlines at x-axis tick positions */
-declare const GridX: import("svelte").Component<GridXMarkProps, {}, "">;
-type GridX = ReturnType<typeof GridX>;
+declare const GridX: $$IsomorphicComponent;
+type GridX<Datum = RawValue> = InstanceType<typeof GridX<Datum>>;
 export default GridX;

package/dist/marks/GridY.svelte

@@ -1,17 +1,14 @@
 <!-- @component
     Renders horizontal gridlines at y-axis tick positions
 -->
-<script module lang="ts">
-    export type GridYMarkProps = Omit<BaseMarkProps, 'fill' | 'fillOpacity'> & {
-        data?: RawValue[];
+<script lang="ts" generics="Datum = RawValue">
+    interface GridYMarkProps extends Omit<BaseMarkProps<Datum>, 'fill' | 'fillOpacity'> {
+        data?: Datum[];
         automatic?: boolean;
-    };
-</script>
-
-<script lang="ts">
+    }
     import { getContext } from 'svelte';
     import Mark from '../Mark.svelte';
-    import type { PlotContext, BaseMarkProps, RawValue, PlotDefaults } from '../types.js';
+    import type { PlotContext, BaseMarkProps, RawValue, PlotDefaults } from '../types/index.js';
     import { resolveChannel, resolveStyles } from '../helpers/resolve.js';
     import { autoTicks } from '../helpers/autoTicks.js';
     import { testFilter } from '../helpers/index.js';

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

@@ -1,9 +1,81 @@
-export type GridYMarkProps = Omit<BaseMarkProps, 'fill' | 'fillOpacity'> & {
-    data?: RawValue[];
-    automatic?: boolean;
-};
-import type { BaseMarkProps, RawValue } from '../types.js';
+import type { RawValue } from '../types/index.js';
+declare class __sveltets_Render<Datum = RawValue> {
+    props(): Omit<Partial<{
+        filter?: import("../types/index.js").ConstantAccessor<boolean, Datum>;
+        facet?: "auto" | "include" | "exclude";
+        fx: import("../types/channel").ChannelAccessor<Datum>;
+        fy: import("../types/channel").ChannelAccessor<Datum>;
+        dx: import("../types/index.js").ConstantAccessor<number, Datum>;
+        dy: import("../types/index.js").ConstantAccessor<number, Datum>;
+        fill: import("../types/channel").ChannelAccessor<Datum>;
+        fillOpacity: import("../types/index.js").ConstantAccessor<number, Datum>;
+        sort: {
+            channel: string;
+            order?: "ascending" | "descending";
+        } | ((a: RawValue, b: RawValue) => number) | import("../types/index.js").ConstantAccessor<RawValue, Datum>;
+        stroke: import("../types/channel").ChannelAccessor<Datum>;
+        strokeWidth: import("../types/index.js").ConstantAccessor<number, Datum>;
+        strokeOpacity: import("../types/index.js").ConstantAccessor<number, Datum>;
+        strokeLinejoin: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, Datum>;
+        strokeLinecap: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, Datum>;
+        strokeMiterlimit: import("../types/index.js").ConstantAccessor<number, Datum>;
+        opacity: import("../types/channel").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>;
+    }>, "fill" | "fillOpacity"> & {
+        data?: Datum[] | undefined;
+        automatic?: boolean;
+    };
+    events(): {};
+    slots(): {};
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Datum = 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 = RawValue>(internal: unknown, props: ReturnType<__sveltets_Render<Datum>['props']> & {}): ReturnType<__sveltets_Render<Datum>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
 /** Renders horizontal gridlines at y-axis tick positions */
-declare const GridY: import("svelte").Component<GridYMarkProps, {}, "">;
-type GridY = ReturnType<typeof GridY>;
+declare const GridY: $$IsomorphicComponent;
+type GridY<Datum = RawValue> = InstanceType<typeof GridY<Datum>>;
 export default GridY;

package/dist/marks/HTMLTooltip.svelte

@@ -2,21 +2,16 @@
     @component
     For showing custom HTML tooltips positioned at x/y coordinates
 -->
-<script module lang="ts">
-    import type { ChannelAccessor, DataRow } from '../types.js';
-
-    export type HTMLTooltipMarkProps = {
-        data: DataRow[];
-        x?: ChannelAccessor;
-        y?: ChannelAccessor;
-        r?: ChannelAccessor;
-        children: Snippet<[{ datum: DataRow }]>;
-    };
-</script>
-
-<script lang="ts">
+<script lang="ts" generics="Datum = DataRow">
+    interface HTMLTooltipMarkProps {
+        data: Datum[];
+        x?: ChannelAccessor<Datum>;
+        y?: ChannelAccessor<Datum>;
+        r?: ChannelAccessor<Datum>;
+        children: Snippet<[{ datum: Datum }]>;
+    }
     import { getContext, type Snippet } from 'svelte';
-    import type { PlotContext } from '../types.js';
+    import type { ChannelAccessor, DataRow, PlotContext } from '../types/index.js';
 
     const { getPlotState } = getContext<PlotContext>('svelteplot');
     let plot = $derived(getPlotState());

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

@@ -1,15 +1,28 @@
-import type { ChannelAccessor, DataRow } from '../types.js';
-export type HTMLTooltipMarkProps = {
-    data: DataRow[];
-    x?: ChannelAccessor;
-    y?: ChannelAccessor;
-    r?: ChannelAccessor;
-    children: Snippet<[{
-        datum: DataRow;
-    }]>;
-};
 import { type Snippet } from 'svelte';
+import type { ChannelAccessor, DataRow } from '../types/index.js';
+declare class __sveltets_Render<Datum = DataRow> {
+    props(): {
+        data: Datum[];
+        x?: ChannelAccessor<Datum>;
+        y?: ChannelAccessor<Datum>;
+        r?: ChannelAccessor<Datum>;
+        children: Snippet<[{
+            datum: Datum;
+        }]>;
+    };
+    events(): {};
+    slots(): {};
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Datum = 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 = DataRow>(internal: unknown, props: ReturnType<__sveltets_Render<Datum>['props']> & {}): ReturnType<__sveltets_Render<Datum>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
 /** For showing custom HTML tooltips positioned at x/y coordinates */
-declare const HtmlTooltip: import("svelte").Component<HTMLTooltipMarkProps, {}, "">;
-type HtmlTooltip = ReturnType<typeof HtmlTooltip>;
+declare const HtmlTooltip: $$IsomorphicComponent;
+type HtmlTooltip<Datum = DataRow> = InstanceType<typeof HtmlTooltip<Datum>>;
 export default HtmlTooltip;

package/dist/marks/Line.svelte

@@ -1,7 +1,26 @@
 <!-- @component
     Creates line charts with connecting points in a dataset with customizable curves and markers
 -->
-<script module lang="ts">
+<script lang="ts" generics="Datum extends DataRecord">
+    interface LineMarkProps extends MarkerOptions, BaseMarkProps<Datum> {
+        data?: Datum[];
+        x?: ChannelAccessor<Datum>;
+        y?: ChannelAccessor<Datum>;
+        z?: ChannelAccessor<Datum>;
+        outlineStroke?: string;
+        outlineStrokeWidth?: number;
+        outlineStrokeOpacity?: number;
+        curve?: CurveName | CurveFactory | 'auto';
+        tension?: number;
+        sort?: ConstantAccessor<RawValue, Datum> | { channel: 'stroke' | 'fill' };
+        text?: ConstantAccessor<string, Datum>;
+        textFill?: ConstantAccessor<string, Datum>;
+        textStroke?: ConstantAccessor<string, Datum>;
+        textStartOffset?: ConstantAccessor<string, Datum>;
+        textStrokeWidth?: ConstantAccessor<number, Datum>;
+        lineClass?: ConstantAccessor<string, Datum>;
+        canvas?: boolean;
+    }
     import type {
         CurveName,
         PlotContext,
@@ -11,31 +30,7 @@
         ChannelAccessor,
         MarkerOptions,
         ScaledDataRecord
-    } from '../types.js';
-
-    export type LineMarkProps = {
-        data: DataRecord[];
-        x?: ChannelAccessor;
-        y?: ChannelAccessor;
-        z?: ChannelAccessor;
-        outlineStroke?: string;
-        outlineStrokeWidth?: number;
-        outlineStrokeOpacity?: number;
-        curve?: CurveName | CurveFactory | 'auto';
-        tension?: number;
-        sort?: ConstantAccessor<RawValue> | { channel: 'stroke' | 'fill' };
-        text?: ConstantAccessor<string>;
-        textFill?: ConstantAccessor<string>;
-        textStroke?: ConstantAccessor<string>;
-        textStartOffset?: ConstantAccessor<string>;
-        textStrokeWidth?: ConstantAccessor<number>;
-        lineClass?: ConstantAccessor<string>;
-        canvas?: boolean;
-    } & MarkerOptions &
-        BaseMarkProps;
-</script>
-
-<script lang="ts">
+    } from '../types/index.js';
     import Mark from '../Mark.svelte';
     import MarkerPath from './helpers/MarkerPath.svelte';
     import { getContext } from 'svelte';
@@ -47,7 +42,7 @@
     import { pick } from 'es-toolkit';
     import LineCanvas from './helpers/LineCanvas.svelte';
 
-    import type { RawValue, PlotDefaults } from '../types.js';
+    import type { RawValue, PlotDefaults } from '../types/index.js';
     import { isValid } from '../helpers/index.js';
     import { sort } from '../transforms/sort.js';
     import { recordizeXY } from '../transforms/recordize.js';
@@ -61,11 +56,11 @@
         canvas: false,
         class: null,
         lineClass: null,
-        ...getContext<PlotDefaults>('svelteplot/_defaults').line
+        ...getContext<Partial<PlotDefaults>>('svelteplot/_defaults').line
     };
 
     const {
-        data = [{}],
+        data = [{} as Datum],
         curve,
         tension,
         text,

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

@@ -1,28 +1,100 @@
-import type { CurveName, DataRecord, BaseMarkProps, ConstantAccessor, ChannelAccessor, MarkerOptions } from '../types.js';
-export type LineMarkProps = {
-    data: DataRecord[];
-    x?: ChannelAccessor;
-    y?: ChannelAccessor;
-    z?: ChannelAccessor;
-    outlineStroke?: string;
-    outlineStrokeWidth?: number;
-    outlineStrokeOpacity?: number;
-    curve?: CurveName | CurveFactory | 'auto';
-    tension?: number;
-    sort?: ConstantAccessor<RawValue> | {
-        channel: 'stroke' | 'fill';
-    };
-    text?: ConstantAccessor<string>;
-    textFill?: ConstantAccessor<string>;
-    textStroke?: ConstantAccessor<string>;
-    textStartOffset?: ConstantAccessor<string>;
-    textStrokeWidth?: ConstantAccessor<number>;
-    lineClass?: ConstantAccessor<string>;
-    canvas?: boolean;
-} & MarkerOptions & BaseMarkProps;
+import type { CurveName, DataRecord, ConstantAccessor, ChannelAccessor, MarkerOptions } from '../types/index.js';
 import { type CurveFactory } from 'd3-shape';
-import type { RawValue } from '../types.js';
+import type { RawValue } from '../types/index.js';
+declare class __sveltets_Render<Datum extends DataRecord> {
+    props(): MarkerOptions & Partial<{
+        filter?: ConstantAccessor<boolean, Datum>;
+        facet?: "auto" | "include" | "exclude";
+        fx: ChannelAccessor<Datum>;
+        fy: ChannelAccessor<Datum>;
+        dx: ConstantAccessor<number, Datum>;
+        dy: ConstantAccessor<number, Datum>;
+        fill: ChannelAccessor<Datum>;
+        fillOpacity: ConstantAccessor<number, Datum>;
+        sort: {
+            channel: string;
+            order?: "ascending" | "descending";
+        } | ((a: import("../types/data.js").RawValue, b: import("../types/data.js").RawValue) => number) | ConstantAccessor<import("../types/data.js").RawValue, Datum>;
+        stroke: 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: 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.js").MouseEventHandler<SVGPathElement>;
+        ondblclick?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onmouseup?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onmousedown?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onmouseenter?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onmousemove?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onmouseleave?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onmouseout?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onmouseover?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onpointercancel?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onpointerdown?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onpointerup?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onpointerenter?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onpointerleave?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onpointermove?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onpointerover?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onpointerout?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ondrag?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ondrop?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ondragstart?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ondragenter?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ondragleave?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ondragover?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ondragend?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ontouchstart?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ontouchmove?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ontouchend?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ontouchcancel?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        oncontextmenu?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onwheel?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        class: string | null;
+        cursor: ConstantAccessor<import("csstype").Property.Cursor, Datum>;
+    }> & {
+        data?: Datum[] | undefined;
+        x?: ChannelAccessor<Datum>;
+        y?: ChannelAccessor<Datum>;
+        z?: ChannelAccessor<Datum>;
+        outlineStroke?: string;
+        outlineStrokeWidth?: number;
+        outlineStrokeOpacity?: number;
+        curve?: CurveName | CurveFactory | "auto";
+        tension?: number;
+        sort?: ConstantAccessor<RawValue, Datum_1> | {
+            channel: "stroke" | "fill";
+        };
+        text?: ConstantAccessor<string, Datum>;
+        textFill?: ConstantAccessor<string, Datum>;
+        textStroke?: ConstantAccessor<string, Datum>;
+        textStartOffset?: ConstantAccessor<string, Datum>;
+        textStrokeWidth?: ConstantAccessor<number, Datum>;
+        lineClass?: ConstantAccessor<string, Datum>;
+        canvas?: boolean;
+    };
+    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']>;
+}
 /** Creates line charts with connecting points in a dataset with customizable curves and markers */
-declare const Line: import("svelte").Component<LineMarkProps, {}, "">;
-type Line = ReturnType<typeof Line>;
+declare const Line: $$IsomorphicComponent;
+type Line<Datum extends DataRecord> = InstanceType<typeof Line<Datum>>;
 export default Line;

package/dist/marks/LineX.svelte

@@ -1,11 +1,16 @@
 <!-- @component
     Creates a horizontal line chart with x values and index positions for y
 -->
-<script lang="ts">
-    import Line, { type LineMarkProps } from './Line.svelte';
-    import { recordizeX } from '../index.js';
+<script lang="ts" generics="Datum extends DataRow">
+    interface LineXMarkProps extends Omit<ComponentProps<typeof Line>, 'y' | 'data'> {
+        data: Datum[];
+    }
+    import Line from './Line.svelte';
+    import { recordizeX } from '..';
+    import type { ComponentProps } from 'svelte';
+    import type { DataRow } from '..';
 
-    let { data = [{}], ...rest }: Omit<LineMarkProps, 'y'> = $props();
+    let { data = [{} as Datum], ...rest }: LineXMarkProps = $props();
 
     let args = $derived(recordizeX({ data, ...rest }));
 </script>

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

@@ -1,5 +1,101 @@
-import { type LineMarkProps } from './Line.svelte';
+import { recordizeX } from '..';
+import type { DataRow } from '..';
+declare class __sveltets_Render<Datum extends DataRow> {
+    props(): Omit<import("../types").MarkerOptions & Partial<{
+        filter?: import("../types").ConstantAccessor<boolean, import("../types").DataRecord>;
+        facet?: "auto" | "include" | "exclude";
+        fx: import("../types").ChannelAccessor<import("../types").DataRecord>;
+        fy: import("../types").ChannelAccessor<import("../types").DataRecord>;
+        dx: import("../types").ConstantAccessor<number, import("../types").DataRecord>;
+        dy: import("../types").ConstantAccessor<number, import("../types").DataRecord>;
+        fill: import("../types").ChannelAccessor<import("../types").DataRecord>;
+        fillOpacity: import("../types").ConstantAccessor<number, import("../types").DataRecord>;
+        sort: {
+            channel: string;
+            order?: "ascending" | "descending";
+        } | ((a: import("../types").RawValue, b: import("../types").RawValue) => number) | import("../types").ConstantAccessor<import("../types").RawValue, import("../types").DataRecord>;
+        stroke: import("../types").ChannelAccessor<import("../types").DataRecord>;
+        strokeWidth: import("../types").ConstantAccessor<number, import("../types").DataRecord>;
+        strokeOpacity: import("../types").ConstantAccessor<number, import("../types").DataRecord>;
+        strokeLinejoin: import("../types").ConstantAccessor<import("csstype").Property.StrokeLinejoin, import("../types").DataRecord>;
+        strokeLinecap: import("../types").ConstantAccessor<import("csstype").Property.StrokeLinecap, import("../types").DataRecord>;
+        strokeMiterlimit: import("../types").ConstantAccessor<number, import("../types").DataRecord>;
+        opacity: import("../types").ChannelAccessor<import("../types").DataRecord>;
+        strokeDasharray: import("../types").ConstantAccessor<string, import("../types").DataRecord>;
+        strokeDashoffset: import("../types").ConstantAccessor<number, import("../types").DataRecord>;
+        mixBlendMode: import("../types").ConstantAccessor<import("csstype").Property.MixBlendMode, import("../types").DataRecord>;
+        clipPath: string;
+        imageFilter: import("../types").ConstantAccessor<string, import("../types").DataRecord>;
+        shapeRendering: import("../types").ConstantAccessor<import("csstype").Property.ShapeRendering, import("../types").DataRecord>;
+        paintOrder: import("../types").ConstantAccessor<string, import("../types").DataRecord>;
+        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").ConstantAccessor<import("csstype").Property.Cursor, import("../types").DataRecord>;
+    }> & {
+        data?: import("../types").DataRecord[] | undefined;
+        x?: import("../types").ChannelAccessor<import("../types").DataRecord>;
+        y?: import("../types").ChannelAccessor<import("../types").DataRecord>;
+        z?: import("../types").ChannelAccessor<import("../types").DataRecord>;
+        outlineStroke?: string;
+        outlineStrokeWidth?: number;
+        outlineStrokeOpacity?: number;
+        curve?: import("../types").CurveName | import("d3-shape").CurveFactory | "auto";
+        tension?: number;
+        sort?: import("../types").ConstantAccessor<recordizeX, Datum_1> | {
+            channel: "stroke" | "fill";
+        };
+        text?: import("../types").ConstantAccessor<string, import("../types").DataRecord>;
+        textFill?: import("../types").ConstantAccessor<string, import("../types").DataRecord>;
+        textStroke?: import("../types").ConstantAccessor<string, import("../types").DataRecord>;
+        textStartOffset?: import("../types").ConstantAccessor<string, import("../types").DataRecord>;
+        textStrokeWidth?: import("../types").ConstantAccessor<number, import("../types").DataRecord>;
+        lineClass?: import("../types").ConstantAccessor<string, import("../types").DataRecord>;
+        canvas?: boolean;
+    }, "y" | "data"> & {
+        data: Datum[];
+    };
+    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']>;
+}
 /** Creates a horizontal line chart with x values and index positions for y */
-declare const LineX: import("svelte").Component<Omit<LineMarkProps, "y">, {}, "">;
-type LineX = ReturnType<typeof LineX>;
+declare const LineX: $$IsomorphicComponent;
+type LineX<Datum extends DataRow> = InstanceType<typeof LineX<Datum>>;
 export default LineX;