svelteplot 0.3.4 → 0.3.5-pr-121.0

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

@@ -1,9 +1,25 @@
-export type RectXMarkProps = Omit<RectMarkProps, 'y'> & {
-    stack?: Partial<StackOptions>;
-};
-import { type RectMarkProps } from './Rect.svelte';
+import Rect from './Rect.svelte';
+import type { DataRecord } from '../types/index.js';
+import { type ComponentProps } from 'svelte';
 import type { StackOptions } from '../transforms/stack';
+interface RectXMarkProps extends Omit<ComponentProps<typeof Rect>, 'y'> {
+    stack?: Partial<StackOptions>;
+}
+declare class __sveltets_Render<Datum extends DataRecord> {
+    props(): RectXMarkProps;
+    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']>;
+}
 /** Convenience wrapper for rectangles oriented along the x axis */
-declare const RectX: import("svelte").Component<RectXMarkProps, {}, "">;
-type RectX = ReturnType<typeof RectX>;
+declare const RectX: $$IsomorphicComponent;
+type RectX<Datum extends DataRecord> = InstanceType<typeof RectX<Datum>>;
 export default RectX;

package/dist/marks/RectY.svelte

@@ -1,15 +1,14 @@
 <!-- @component
     Convenience wrapper for rectangles oriented along the x axis 
 -->
-<script module lang="ts">
-    export type RectYMarkProps = Omit<RectMarkProps, 'x'> & { stack?: Partial<StackOptions> };
-</script>
-
-<script lang="ts">
-    import Rect, { type RectMarkProps } from './Rect.svelte';
-    import { intervalX, stackY, recordizeY } from '../index.js';
-    import type { PlotContext, PlotDefaults } from '../types.js';
-    import { getContext } from 'svelte';
+<script lang="ts" generics="Datum extends DataRecord">
+    interface RectYMarkProps extends Omit<ComponentProps<typeof Rect>, 'y'> {
+        stack?: Partial<StackOptions>;
+    }
+    import Rect from './Rect.svelte';
+    import { intervalX, stackY, recordizeY } from '..';
+    import type { DataRecord, PlotContext, PlotDefaults } from '../types/index.js';
+    import { getContext, type ComponentProps } from 'svelte';
     import type { StackOptions } from '../transforms/stack';
 
     let markProps: RectYMarkProps = $props();
@@ -20,7 +19,7 @@
     };
 
     const {
-        data = [{}],
+        data = [{} as Datum],
         stack,
         ...options
     }: RectYMarkProps = $derived({

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

@@ -1,9 +1,25 @@
-export type RectYMarkProps = Omit<RectMarkProps, 'x'> & {
-    stack?: Partial<StackOptions>;
-};
-import { type RectMarkProps } from './Rect.svelte';
+import Rect from './Rect.svelte';
+import type { DataRecord } from '../types/index.js';
+import { type ComponentProps } from 'svelte';
 import type { StackOptions } from '../transforms/stack';
+interface RectYMarkProps extends Omit<ComponentProps<typeof Rect>, 'y'> {
+    stack?: Partial<StackOptions>;
+}
+declare class __sveltets_Render<Datum extends DataRecord> {
+    props(): RectYMarkProps;
+    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']>;
+}
 /** Convenience wrapper for rectangles oriented along the x axis */
-declare const RectY: import("svelte").Component<RectYMarkProps, {}, "">;
-type RectY = ReturnType<typeof RectY>;
+declare const RectY: $$IsomorphicComponent;
+type RectY<Datum extends DataRecord> = InstanceType<typeof RectY<Datum>>;
 export default RectY;

package/dist/marks/RegressionX.svelte

@@ -8,7 +8,7 @@
 
 <script lang="ts">
     import { resolveChannel } from '../helpers/resolve.js';
-    import type { ChannelName } from '../types.js';
+    import type { ChannelName } from '../types/index.js';
     import Mark from '../Mark.svelte';
     import Regression, { type RegressionMarkProps } from './helpers/Regression.svelte';
     import { groups as d3Groups } from 'd3-array';

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

@@ -1,6 +1,6 @@
 export type RegressionXMarkProps = RegressionMarkProps;
 import { type RegressionMarkProps } from './helpers/Regression.svelte';
 /** Calculates and displays a regression line with x as the dependent variable */
-declare const RegressionX: import("svelte").Component<RegressionMarkProps, {}, "">;
+declare const RegressionX: import("svelte").Component<any, {}, "">;
 type RegressionX = ReturnType<typeof RegressionX>;
 export default RegressionX;

package/dist/marks/RegressionY.svelte

@@ -7,7 +7,7 @@
 
 <script lang="ts">
     import { resolveChannel } from '../helpers/resolve.js';
-    import type { ChannelName } from '../types.js';
+    import type { ChannelName } from '../types/index.js';
     import Mark from '../Mark.svelte';
     import Regression, { type RegressionMarkProps } from './helpers/Regression.svelte';
     import { groups as d3Groups } from 'd3-array';

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

@@ -1,6 +1,6 @@
 export type RegressionYMarkProps = RegressionMarkProps;
 import { type RegressionMarkProps } from './helpers/Regression.svelte';
 /** Calculates and displays a regression line with y as the dependent variable */
-declare const RegressionY: import("svelte").Component<RegressionMarkProps, {}, "">;
+declare const RegressionY: import("svelte").Component<any, {}, "">;
 type RegressionY = ReturnType<typeof RegressionY>;
 export default RegressionY;

package/dist/marks/RuleX.svelte

@@ -1,19 +1,16 @@
 <!-- @component
     Renders vertical rule lines at specified x positions with customizable vertical range
 -->
-<script module lang="ts">
-    export type RuleXMarkProps = Omit<BaseMarkProps, 'fill' | 'fillOpacity'> & {
-        data: DataRecord[];
-        x?: ChannelAccessor;
-        y1?: ChannelAccessor;
-        y2?: ChannelAccessor;
-        inset?: ConstantAccessor<number>;
-        insetTop?: ConstantAccessor<number>;
-        insetBottom?: ConstantAccessor<number>;
-    };
-</script>
-
-<script lang="ts">
+<script lang="ts" generics="Datum = DataRecord | RawValue">
+    interface RuleXMarkProps extends Omit<BaseMarkProps<Datum>, 'fill' | 'fillOpacity'> {
+        data: Datum[];
+        x?: ChannelAccessor<Datum>;
+        y1?: ChannelAccessor<Datum>;
+        y2?: ChannelAccessor<Datum>;
+        inset?: ConstantAccessor<number, Datum>;
+        insetTop?: ConstantAccessor<number, Datum>;
+        insetBottom?: ConstantAccessor<number, Datum>;
+    }
     import Mark from '../Mark.svelte';
     import GroupMultiple from './helpers/GroupMultiple.svelte';
     import { getContext } from 'svelte';
@@ -25,8 +22,9 @@
         BaseMarkProps,
         ConstantAccessor,
         ChannelAccessor,
-        PlotDefaults
-    } from '../types.js';
+        PlotDefaults,
+        RawValue
+    } from '../types/index.js';
 
     let markProps: RuleXMarkProps = $props();
     const DEFAULTS = {
@@ -34,7 +32,7 @@
         ...getContext<PlotDefaults>('svelteplot/_defaults').ruleX
     };
     const {
-        data = [{}],
+        data = [{} as Datum],
         class: className = '',
         ...options
     }: RuleXMarkProps = $derived({

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

@@ -1,14 +1,86 @@
-export type RuleXMarkProps = Omit<BaseMarkProps, 'fill' | 'fillOpacity'> & {
-    data: DataRecord[];
-    x?: ChannelAccessor;
-    y1?: ChannelAccessor;
-    y2?: ChannelAccessor;
-    inset?: ConstantAccessor<number>;
-    insetTop?: ConstantAccessor<number>;
-    insetBottom?: ConstantAccessor<number>;
-};
-import type { DataRecord, BaseMarkProps, ConstantAccessor, ChannelAccessor } from '../types.js';
+import type { DataRecord, ConstantAccessor, ChannelAccessor, RawValue } from '../types/index.js';
+declare class __sveltets_Render<Datum = DataRecord | RawValue> {
+    props(): Omit<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: RawValue, b: RawValue) => number) | ConstantAccessor<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").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"> & {
+        data: Datum[];
+        x?: ChannelAccessor<Datum>;
+        y1?: ChannelAccessor<Datum>;
+        y2?: ChannelAccessor<Datum>;
+        inset?: ConstantAccessor<number, Datum>;
+        insetTop?: ConstantAccessor<number, Datum>;
+        insetBottom?: ConstantAccessor<number, Datum>;
+    };
+    events(): {};
+    slots(): {};
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Datum = DataRecord | 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 = DataRecord | RawValue>(internal: unknown, props: ReturnType<__sveltets_Render<Datum>['props']> & {}): ReturnType<__sveltets_Render<Datum>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
 /** Renders vertical rule lines at specified x positions with customizable vertical range */
-declare const RuleX: import("svelte").Component<RuleXMarkProps, {}, "">;
-type RuleX = ReturnType<typeof RuleX>;
+declare const RuleX: $$IsomorphicComponent;
+type RuleX<Datum = DataRecord | RawValue> = InstanceType<typeof RuleX<Datum>>;
 export default RuleX;

package/dist/marks/RuleY.svelte

@@ -1,19 +1,16 @@
 <!-- @component
     Renders horizontal rule lines at specified y positions with customizable horizontal range
 -->
-<script module lang="ts">
-    export type RuleYMarkProps = Omit<BaseMarkProps, 'fill' | 'fillOpacity'> & {
-        data: DataRecord[];
-        y?: ChannelAccessor;
-        x1?: ChannelAccessor;
-        x2?: ChannelAccessor;
-        inset?: ConstantAccessor<number>;
-        insetLeft?: ConstantAccessor<number>;
-        insetRight?: ConstantAccessor<number>;
-    };
-</script>
-
-<script lang="ts">
+<script lang="ts" generics="Datum = DataRecord">
+    interface RuleYMarkProps extends Omit<BaseMarkProps<Datum>, 'fill' | 'fillOpacity'> {
+        data?: Datum[];
+        y?: ChannelAccessor<Datum>;
+        x1?: ChannelAccessor<Datum>;
+        x2?: ChannelAccessor<Datum>;
+        inset?: ConstantAccessor<number, Datum>;
+        insetLeft?: ConstantAccessor<number, Datum>;
+        insetRight?: ConstantAccessor<number, Datum>;
+    }
     import Mark from '../Mark.svelte';
     import GroupMultiple from './helpers/GroupMultiple.svelte';
     import { getContext } from 'svelte';
@@ -26,7 +23,7 @@
         ConstantAccessor,
         ChannelAccessor,
         PlotDefaults
-    } from '../types.js';
+    } from '../types/index.js';
 
     let markProps: RuleYMarkProps = $props();
     const DEFAULTS = {
@@ -34,7 +31,7 @@
         ...getContext<PlotDefaults>('svelteplot/_defaults').ruleY
     };
     const {
-        data = [{}],
+        data = [{} as Datum],
         class: className = '',
         ...options
     }: RuleYMarkProps = $derived({

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

@@ -1,14 +1,86 @@
-export type RuleYMarkProps = Omit<BaseMarkProps, 'fill' | 'fillOpacity'> & {
-    data: DataRecord[];
-    y?: ChannelAccessor;
-    x1?: ChannelAccessor;
-    x2?: ChannelAccessor;
-    inset?: ConstantAccessor<number>;
-    insetLeft?: ConstantAccessor<number>;
-    insetRight?: ConstantAccessor<number>;
-};
-import type { DataRecord, BaseMarkProps, ConstantAccessor, ChannelAccessor } from '../types.js';
+import type { DataRecord, ConstantAccessor, ChannelAccessor } from '../types/index.js';
+declare class __sveltets_Render<Datum = DataRecord> {
+    props(): Omit<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").RawValue, b: import("../types/data").RawValue) => number) | ConstantAccessor<import("../types/data").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").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"> & {
+        data?: Datum[] | undefined;
+        y?: ChannelAccessor<Datum>;
+        x1?: ChannelAccessor<Datum>;
+        x2?: ChannelAccessor<Datum>;
+        inset?: ConstantAccessor<number, Datum>;
+        insetLeft?: ConstantAccessor<number, Datum>;
+        insetRight?: ConstantAccessor<number, Datum>;
+    };
+    events(): {};
+    slots(): {};
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Datum = 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 = DataRecord>(internal: unknown, props: ReturnType<__sveltets_Render<Datum>['props']> & {}): ReturnType<__sveltets_Render<Datum>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
 /** Renders horizontal rule lines at specified y positions with customizable horizontal range */
-declare const RuleY: import("svelte").Component<RuleYMarkProps, {}, "">;
-type RuleY = ReturnType<typeof RuleY>;
+declare const RuleY: $$IsomorphicComponent;
+type RuleY<Datum = DataRecord> = InstanceType<typeof RuleY<Datum>>;
 export default RuleY;

package/dist/marks/Sphere.svelte

@@ -1,15 +1,14 @@
 <!-- @component
     Geo mark with Sphere geometry object  -->
 
-<script module lang="ts">
-    import { type BaseMarkProps, type LinkableMarkProps } from '../types.js';
-    export type SphereMarkProps = BaseMarkProps & LinkableMarkProps;
-</script>
-
 <script lang="ts">
-    import Geo from './Geo.svelte';
+    interface SphereMarkProps
+        extends BaseMarkProps<GeoJSON.GeoJsonObject>,
+            LinkableMarkProps<GeoJSON.GeoJsonObject> {}
+
     import { getContext } from 'svelte';
-    import type { PlotDefaults } from '../types.js';
+    import Geo from './Geo.svelte';
+    import type { BaseMarkProps, LinkableMarkProps, PlotDefaults } from '../types/index.js';
 
     let markProps: SphereMarkProps = $props();
 

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

@@ -1,5 +1,6 @@
-import { type BaseMarkProps, type LinkableMarkProps } from '../types.js';
-export type SphereMarkProps = BaseMarkProps & LinkableMarkProps;
+import type { BaseMarkProps, LinkableMarkProps } from '../types/index.js';
+interface SphereMarkProps extends BaseMarkProps<GeoJSON.GeoJsonObject>, LinkableMarkProps<GeoJSON.GeoJsonObject> {
+}
 /** Geo mark with Sphere geometry object */
 declare const Sphere: import("svelte").Component<SphereMarkProps, {}, "">;
 type Sphere = ReturnType<typeof Sphere>;

package/dist/marks/Spike.svelte

@@ -2,14 +2,22 @@
     @component
     Wrapper around the vector mark with presets suitable for spike maps 
 -->
-<script module lang="ts">
-    export type SpikeMarkProps = VectorMarkProps;
-</script>
-
-<script lang="ts">
-    import Vector, { type VectorMarkProps } from './Vector.svelte';
-    import type { PlotDefaults } from '../types.js';
-    import { getContext } from 'svelte';
+<script lang="ts" generics="Datum extends DataRecord">
+    interface SpikeMarkProps
+        extends Omit<
+            ComponentProps<typeof Vector>,
+            'data' | 'x' | 'y' | 'r' | 'length' | 'rotate'
+        > {
+        data: Datum[];
+        x: ChannelAccessor<Datum>;
+        y: ChannelAccessor<Datum>;
+        r?: number;
+        length?: ChannelAccessor<Datum>;
+        rotate?: ChannelAccessor<Datum>;
+    }
+    import Vector from './Vector.svelte';
+    import type { ChannelAccessor, DataRecord, PlotDefaults } from '../types/index.js';
+    import { getContext, type ComponentProps } from 'svelte';
 
     let markProps: SpikeMarkProps = $props();
 
@@ -24,7 +32,7 @@
         ...getContext<PlotDefaults>('svelteplot/_defaults').spike
     };
 
-    const { data = [{}], ...options }: SpikeMarkProps = $derived({
+    const { data = [{} as Datum], ...options }: SpikeMarkProps = $derived({
         ...DEFAULTS,
         ...markProps
     });

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

@@ -1,6 +1,96 @@
-export type SpikeMarkProps = VectorMarkProps;
-import { type VectorMarkProps } from './Vector.svelte';
+import type { ChannelAccessor, DataRecord } from '../types/index.js';
+declare class __sveltets_Render<Datum extends DataRecord> {
+    props(): Omit<Partial<{
+        filter?: import("../types/index.js").ConstantAccessor<boolean, DataRecord>;
+        facet?: "auto" | "include" | "exclude";
+        fx: ChannelAccessor<DataRecord>;
+        fy: ChannelAccessor<DataRecord>;
+        dx: import("../types/index.js").ConstantAccessor<number, DataRecord>;
+        dy: import("../types/index.js").ConstantAccessor<number, DataRecord>;
+        fill: ChannelAccessor<DataRecord>;
+        fillOpacity: import("../types/index.js").ConstantAccessor<number, DataRecord>;
+        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, DataRecord>;
+        stroke: ChannelAccessor<DataRecord>;
+        strokeWidth: import("../types/index.js").ConstantAccessor<number, DataRecord>;
+        strokeOpacity: import("../types/index.js").ConstantAccessor<number, DataRecord>;
+        strokeLinejoin: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, DataRecord>;
+        strokeLinecap: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, DataRecord>;
+        strokeMiterlimit: import("../types/index.js").ConstantAccessor<number, DataRecord>;
+        opacity: ChannelAccessor<DataRecord>;
+        strokeDasharray: import("../types/index.js").ConstantAccessor<string, DataRecord>;
+        strokeDashoffset: import("../types/index.js").ConstantAccessor<number, DataRecord>;
+        mixBlendMode: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, DataRecord>;
+        clipPath: string;
+        imageFilter: import("../types/index.js").ConstantAccessor<string, DataRecord>;
+        shapeRendering: import("../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, DataRecord>;
+        paintOrder: import("../types/index.js").ConstantAccessor<string, 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/index.js").ConstantAccessor<import("csstype").Property.Cursor, DataRecord>;
+    }> & {
+        data: DataRecord[];
+        x: ChannelAccessor<DataRecord>;
+        y: ChannelAccessor<DataRecord>;
+        r?: number;
+        length?: ChannelAccessor<DataRecord>;
+        rotate?: ChannelAccessor<DataRecord>;
+        anchor?: "start" | "middle" | "end";
+        shape?: "arrow" | "spike" | "arrow-filled" | import("./Vector.svelte").ShapeRenderer;
+        children?: import("svelte").Snippet;
+        canvas?: boolean;
+    }, "r" | "length" | "x" | "y" | "data" | "rotate"> & {
+        data: Datum[];
+        x: ChannelAccessor<Datum>;
+        y: ChannelAccessor<Datum>;
+        r?: number;
+        length?: ChannelAccessor<Datum>;
+        rotate?: ChannelAccessor<Datum>;
+    };
+    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']>;
+}
 /** Wrapper around the vector mark with presets suitable for spike maps */
-declare const Spike: import("svelte").Component<VectorMarkProps, {}, "">;
-type Spike = ReturnType<typeof Spike>;
+declare const Spike: $$IsomorphicComponent;
+type Spike<Datum extends DataRecord> = InstanceType<typeof Spike<Datum>>;
 export default Spike;

package/dist/marks/SymbolLegend.svelte

@@ -2,7 +2,7 @@
     import { getContext } from 'svelte';
     import { symbol as d3Symbol } from 'd3-shape';
     import { maybeSymbol } from '../helpers/symbols.js';
-    import type { PlotContext } from '../types.js';
+    import type { PlotContext } from '../types/index.js';
 
     const { getPlotState } = getContext<PlotContext>('svelteplot');
     let plot = $derived(getPlotState());