svelteplot 0.3.1 → 0.3.2-pr-113.0

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

@@ -1,30 +1,61 @@
-export type DifferenceYMarkProps = Omit<BaseMarkProps, 'fill' | 'fillOpacity'> & {
-    data: DataRecord[];
-    x1: ChannelAccessor;
-    /**
-     * the horizontal position of the metric; bound to the x scale
-     */
-    x2: ChannelAccessor;
-    x: ChannelAccessor;
-    /**
-     * the vertical position of the comparison; bound to the y scale
-     */
-    y1: ChannelAccessor;
-    /**
-     * the vertical position of the metric; bound to the y scale
-     */
-    y2: ChannelAccessor;
-    y: ChannelAccessor;
-    fillOpacity?: number;
-    positiveFill?: string;
-    positiveFillOpacity?: number;
-    negativeFill?: string;
-    negativeFillOpacity?: number;
-    curve?: CurveName | CurveFactory;
-    tension?: number;
-};
-import type { BaseMarkProps, ChannelAccessor, CurveName, DataRecord } from '../types.js';
+import type { ChannelAccessor, CurveName, DataRecord } from '../types/index.js';
 import type { CurveFactory } from 'd3-shape';
-declare const DifferenceY: import("svelte").Component<DifferenceYMarkProps, {}, "">;
-type DifferenceY = ReturnType<typeof DifferenceY>;
+declare class __sveltets_Render<Datum extends DataRecord> {
+    props(): Omit<BaseMarkProps<Datum_1>, "fill" | "fillOpacity"> & {
+        data: Datum[];
+        x1: ChannelAccessor<Datum_1>;
+        /**
+         * the horizontal position of the metric; bound to the x scale
+         */
+        x2: ChannelAccessor<Datum_1>;
+        x: ChannelAccessor<Datum_1>;
+        /**
+         * the vertical position of the comparison; bound to the y scale
+         */
+        y1: ChannelAccessor<Datum_1>;
+        /**
+         * the vertical position of the metric; bound to the y scale
+         */
+        y2: ChannelAccessor<Datum_1>;
+        y: ChannelAccessor<Datum_1>;
+        fillOpacity?: number;
+        /**
+         * the stroke color of the "positive" area; defaults to 'blue'
+         */
+        positiveFill?: string;
+        /**
+         * the fill opacity of the "positive" area; defaults to 1
+         */
+        positiveFillOpacity?: number;
+        /**
+         * the stroke color of the "negative" area; defaults to 'red'
+         */
+        negativeFill?: string;
+        /**
+         * the fill opacity of the "negative" area; defaults to 1
+         */
+        negativeFillOpacity?: number;
+        /**
+         * curve type for the area; defaults to 'linear'
+         */
+        curve?: CurveName | CurveFactory;
+        /**
+         * the tension of the area curve; defaults to 0
+         */
+        tension?: number;
+    };
+    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']>;
+}
+declare const DifferenceY: $$IsomorphicComponent;
+type DifferenceY<Datum extends DataRecord> = InstanceType<typeof DifferenceY<Datum>>;
 export default DifferenceY;

package/dist/marks/Dot.svelte

@@ -1,19 +1,17 @@
 <!-- @component
     Creates dots or symbols at specified positions with customizable size and appearance
 -->
-<script module lang="ts">
-    export type DotMarkProps = BaseMarkProps & {
-        data: DataRecord[];
-        x: ChannelAccessor;
-        y: ChannelAccessor;
-        r?: ChannelAccessor;
-        symbol?: ChannelAccessor | Snippet<[number, string]>;
+<script lang="ts" generics="Datum extends DataRecord">
+    interface DotMarkProps extends BaseMarkProps<Datum>, LinkableMarkProps<Datum> {
+        data: Datum[];
+        x: ChannelAccessor<Datum>;
+        y: ChannelAccessor<Datum>;
+        r?: ChannelAccessor<Datum>;
+        symbol?: ChannelAccessor<Datum> | Snippet<[number, string]>;
         canvas?: boolean;
-        dotClass?: ConstantAccessor<string>;
-    } & LinkableMarkProps;
-</script>
+        dotClass?: ConstantAccessor<string, Datum>;
+    }
 
-<script lang="ts">
     import { getContext, type Snippet } from 'svelte';
     import type {
         PlotContext,
@@ -23,17 +21,18 @@
         ChannelAccessor,
         PlotDefaults,
         LinkableMarkProps
-    } from '../types.js';
+    } from '../types/index.js';
     import { resolveProp, resolveStyles } from '../helpers/resolve.js';
     import { maybeSymbol } from '../helpers/symbols.js';
     import { symbol as d3Symbol } from 'd3-shape';
-    import { sort } from '../index.js';
+    import { sort } from '..';
     import Mark from '../Mark.svelte';
     import DotCanvas from './helpers/DotCanvas.svelte';
     import { maybeData, isValid } from '../helpers/index.js';
     import { recordizeXY } from '../transforms/recordize.js';
     import { addEventHandlers } from './helpers/events.js';
     import Anchor from './helpers/Anchor.svelte';
+    import type { D } from 'vitest/dist/chunks/reporters.d.DL9pg5DB.js';
 
     const DEFAULTS = {
         ...getContext<PlotDefaults>('svelteplot/_defaults').dot
@@ -42,7 +41,7 @@
     let markProps: DotMarkProps = $props();
 
     const {
-        data = [{}],
+        data = [{} as Datum],
         canvas = false,
         class: className = '',
         dotClass = null,

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

@@ -1,15 +1,87 @@
-export type DotMarkProps = BaseMarkProps & {
-    data: DataRecord[];
-    x: ChannelAccessor;
-    y: ChannelAccessor;
-    r?: ChannelAccessor;
-    symbol?: ChannelAccessor | Snippet<[number, string]>;
-    canvas?: boolean;
-    dotClass?: ConstantAccessor<string>;
-} & LinkableMarkProps;
 import { type Snippet } from 'svelte';
-import type { DataRecord, BaseMarkProps, ConstantAccessor, ChannelAccessor, LinkableMarkProps } from '../types.js';
+import type { DataRecord, ConstantAccessor, ChannelAccessor, LinkableMarkProps } from '../types/index.js';
+declare class __sveltets_Render<Datum extends DataRecord> {
+    props(): 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>;
+    }> & LinkableMarkProps<Datum> & {
+        data: Datum[];
+        x: ChannelAccessor<Datum>;
+        y: ChannelAccessor<Datum>;
+        r?: ChannelAccessor<Datum>;
+        symbol?: Snippet<[number, string]> | ChannelAccessor<Datum>;
+        canvas?: boolean;
+        dotClass?: ConstantAccessor<string, 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']>;
+}
 /** Creates dots or symbols at specified positions with customizable size and appearance */
-declare const Dot: import("svelte").Component<DotMarkProps, {}, "">;
-type Dot = ReturnType<typeof Dot>;
+declare const Dot: $$IsomorphicComponent;
+type Dot<Datum extends DataRecord> = InstanceType<typeof Dot<Datum>>;
 export default Dot;

package/dist/marks/DotX.svelte

@@ -1,16 +1,16 @@
 <!-- @component
     Creates a horizontal dot plot with x values along a single y position
 -->
-<script module lang="ts">
-    export type DotXMarkProps = Omit<DotMarkProps, 'y'>;
-</script>
-
-<script lang="ts">
-    import Dot, { type DotMarkProps } from './Dot.svelte';
-    import { recordizeX } from '../index.js';
-    import type { DataRow } from '../types.js';
+<script lang="ts" generics="Datum extends DataRow">
+    interface DotXMarkProps extends Omit<ComponentProps<typeof Dot>, 'y' | 'data'> {
+        data: Datum[];
+    }
+    import Dot from './Dot.svelte';
+    import { recordizeX } from '..';
+    import type { DataRow } from '../types/index.js';
+    import type { ComponentProps } from 'svelte';
 
-    let { data = [{}], ...options }: DotXMarkProps = $props();
+    let { data = [{} as Datum], ...options }: DotXMarkProps = $props();
 
     const args = $derived(recordizeX({ data, ...options, y: 1 }, { withIndex: false }));
 </script>

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

@@ -1,6 +1,88 @@
-export type DotXMarkProps = Omit<DotMarkProps, 'y'>;
-import { type DotMarkProps } from './Dot.svelte';
+import type { DataRow } from '../types/index.js';
+declare class __sveltets_Render<Datum extends DataRow> {
+    props(): Omit<Partial<{
+        filter?: import("../types/index.js").ConstantAccessor<boolean, import("../types/data").DataRecord>;
+        facet?: "auto" | "include" | "exclude";
+        fx: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord>;
+        fy: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord>;
+        dx: import("../types/index.js").ConstantAccessor<number, import("../types/data").DataRecord>;
+        dy: import("../types/index.js").ConstantAccessor<number, import("../types/data").DataRecord>;
+        fill: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord>;
+        fillOpacity: import("../types/index.js").ConstantAccessor<number, import("../types/data").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, import("../types/data").DataRecord>;
+        stroke: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord>;
+        strokeWidth: import("../types/index.js").ConstantAccessor<number, import("../types/data").DataRecord>;
+        strokeOpacity: import("../types/index.js").ConstantAccessor<number, import("../types/data").DataRecord>;
+        strokeLinejoin: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, import("../types/data").DataRecord>;
+        strokeLinecap: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, import("../types/data").DataRecord>;
+        strokeMiterlimit: import("../types/index.js").ConstantAccessor<number, import("../types/data").DataRecord>;
+        opacity: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord>;
+        strokeDasharray: import("../types/index.js").ConstantAccessor<string, import("../types/data").DataRecord>;
+        strokeDashoffset: import("../types/index.js").ConstantAccessor<number, import("../types/data").DataRecord>;
+        mixBlendMode: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, import("../types/data").DataRecord>;
+        clipPath: string;
+        imageFilter: import("../types/index.js").ConstantAccessor<string, import("../types/data").DataRecord>;
+        shapeRendering: import("../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, import("../types/data").DataRecord>;
+        paintOrder: import("../types/index.js").ConstantAccessor<string, import("../types/data").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, import("../types/data").DataRecord>;
+    }> & import("../types/mark").LinkableMarkProps<import("../types/data").DataRecord> & {
+        data: import("../types/data").DataRecord[];
+        x: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord>;
+        y: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord>;
+        r?: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord>;
+        symbol?: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord> | import("svelte").Snippet<[number, string]>;
+        canvas?: boolean;
+        dotClass?: import("../types/index.js").ConstantAccessor<string, import("../types/data").DataRecord>;
+    }, "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 dot plot with x values along a single y position */
-declare const DotX: import("svelte").Component<DotXMarkProps, {}, "">;
-type DotX = ReturnType<typeof DotX>;
+declare const DotX: $$IsomorphicComponent;
+type DotX<Datum extends DataRow> = InstanceType<typeof DotX<Datum>>;
 export default DotX;

package/dist/marks/DotY.svelte

@@ -1,15 +1,16 @@
 <!-- @component
-    Creates a vertical dot plot with y values along a single x position
+    Creates a horizontal dot plot with x values along a single y position
 -->
-<script module lang="ts">
-    export type DotYMarkProps = Omit<DotMarkProps, 'y'>;
-</script>
-
-<script lang="ts">
-    import Dot, { type DotMarkProps } from './Dot.svelte';
-    import { recordizeY } from '../index.js';
+<script lang="ts" generics="Datum extends DataRow">
+    interface DotYMarkProps extends Omit<ComponentProps<typeof Dot>, 'x' | 'data'> {
+        data: Datum[];
+    }
+    import Dot from './Dot.svelte';
+    import { recordizeY } from '..';
+    import type { DataRow } from '../types/index.js';
+    import type { ComponentProps } from 'svelte';
 
-    let { data = [{}], ...options }: DotYMarkProps = $props();
+    let { data = [{} as Datum], ...options }: DotYMarkProps = $props();
 
     const args = $derived(recordizeY({ data, ...options, x: 0 }, { withIndex: false }));
 </script>

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

@@ -1,6 +1,88 @@
-export type DotYMarkProps = Omit<DotMarkProps, 'y'>;
-import { type DotMarkProps } from './Dot.svelte';
-/** Creates a vertical dot plot with y values along a single x position */
-declare const DotY: import("svelte").Component<DotYMarkProps, {}, "">;
-type DotY = ReturnType<typeof DotY>;
+import type { DataRow } from '../types/index.js';
+declare class __sveltets_Render<Datum extends DataRow> {
+    props(): Omit<Partial<{
+        filter?: import("../types/index.js").ConstantAccessor<boolean, import("../types/data").DataRecord>;
+        facet?: "auto" | "include" | "exclude";
+        fx: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord>;
+        fy: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord>;
+        dx: import("../types/index.js").ConstantAccessor<number, import("../types/data").DataRecord>;
+        dy: import("../types/index.js").ConstantAccessor<number, import("../types/data").DataRecord>;
+        fill: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord>;
+        fillOpacity: import("../types/index.js").ConstantAccessor<number, import("../types/data").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, import("../types/data").DataRecord>;
+        stroke: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord>;
+        strokeWidth: import("../types/index.js").ConstantAccessor<number, import("../types/data").DataRecord>;
+        strokeOpacity: import("../types/index.js").ConstantAccessor<number, import("../types/data").DataRecord>;
+        strokeLinejoin: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, import("../types/data").DataRecord>;
+        strokeLinecap: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, import("../types/data").DataRecord>;
+        strokeMiterlimit: import("../types/index.js").ConstantAccessor<number, import("../types/data").DataRecord>;
+        opacity: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord>;
+        strokeDasharray: import("../types/index.js").ConstantAccessor<string, import("../types/data").DataRecord>;
+        strokeDashoffset: import("../types/index.js").ConstantAccessor<number, import("../types/data").DataRecord>;
+        mixBlendMode: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, import("../types/data").DataRecord>;
+        clipPath: string;
+        imageFilter: import("../types/index.js").ConstantAccessor<string, import("../types/data").DataRecord>;
+        shapeRendering: import("../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, import("../types/data").DataRecord>;
+        paintOrder: import("../types/index.js").ConstantAccessor<string, import("../types/data").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, import("../types/data").DataRecord>;
+    }> & import("../types/mark").LinkableMarkProps<import("../types/data").DataRecord> & {
+        data: import("../types/data").DataRecord[];
+        x: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord>;
+        y: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord>;
+        r?: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord>;
+        symbol?: import("../types/channel").ChannelAccessor<import("../types/data").DataRecord> | import("svelte").Snippet<[number, string]>;
+        canvas?: boolean;
+        dotClass?: import("../types/index.js").ConstantAccessor<string, import("../types/data").DataRecord>;
+    }, "x" | "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 dot plot with x values along a single y position */
+declare const DotY: $$IsomorphicComponent;
+type DotY<Datum extends DataRow> = InstanceType<typeof DotY<Datum>>;
 export default DotY;

package/dist/marks/Frame.svelte

@@ -2,39 +2,32 @@
     @component 
     Renders a simple frame around the entire plot domain 
 -->
-<script module lang="ts">
-    export type FrameMarkProps = Omit<
-        BaseMarkProps,
-        'fill' | 'stroke' | 'fillOpacity' | 'strokeOpacity'
-    > &
-        LinkableMarkProps &
-        Omit<
-            BaseRectMarkProps,
-            'inset' | 'insetLeft' | 'insetRight' | 'insetTop' | 'insetBottom'
-        > & {
-            fill: string;
-            stroke: string;
-            fillOpacity: number;
-            strokeOpacity: number;
-            automatic?: boolean;
-            inset?: number;
-            insetLeft?: number;
-            insetRight?: number;
-            insetTop?: number;
-            insetBottom?: number;
-        };
-</script>
-
-<script lang="ts">
+<script lang="ts" generics="Datum extends DataRecord">
+    interface FrameMarkProps
+        extends Omit<BaseMarkProps<Datum>, 'fill' | 'stroke' | 'fillOpacity' | 'strokeOpacity'>,
+            BaseRectMarkProps<Datum>,
+            LinkableMarkProps<Datum> {
+        fill?: string;
+        stroke?: string;
+        fillOpacity?: number;
+        strokeOpacity?: number;
+        automatic?: boolean;
+        inset?: number;
+        insetLeft?: number;
+        insetRight?: number;
+        insetTop?: number;
+        insetBottom?: number;
+    }
     import Mark from '../Mark.svelte';
     import { getContext } from 'svelte';
     import type {
         PlotContext,
         BaseRectMarkProps,
         LinkableMarkProps,
-        PlotDefaults
-    } from '../types.js';
-    import type { BaseMarkProps } from '../types.js';
+        PlotDefaults,
+        DataRecord
+    } from '../types/index.js';
+    import type { BaseMarkProps } from '../types/index.js';
     import RectPath from './helpers/RectPath.svelte';
 
     let markProps: FrameMarkProps = $props();

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

@@ -1,18 +1,32 @@
-export type FrameMarkProps = Omit<BaseMarkProps, 'fill' | 'stroke' | 'fillOpacity' | 'strokeOpacity'> & LinkableMarkProps & Omit<BaseRectMarkProps, 'inset' | 'insetLeft' | 'insetRight' | 'insetTop' | 'insetBottom'> & {
-    fill: string;
-    stroke: string;
-    fillOpacity: number;
-    strokeOpacity: number;
+import type { BaseRectMarkProps, LinkableMarkProps, DataRecord } from '../types/index.js';
+import type { BaseMarkProps } from '../types/index.js';
+interface FrameMarkProps extends Omit<BaseMarkProps<Datum>, 'fill' | 'stroke' | 'fillOpacity' | 'strokeOpacity'>, BaseRectMarkProps<Datum>, LinkableMarkProps<Datum> {
+    fill?: string;
+    stroke?: string;
+    fillOpacity?: number;
+    strokeOpacity?: number;
     automatic?: boolean;
     inset?: number;
     insetLeft?: number;
     insetRight?: number;
     insetTop?: number;
     insetBottom?: number;
-};
-import type { BaseRectMarkProps, LinkableMarkProps } from '../types.js';
-import type { BaseMarkProps } from '../types.js';
+}
+declare class __sveltets_Render<Datum extends DataRecord> {
+    props(): FrameMarkProps;
+    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']>;
+}
 /** Renders a simple frame around the entire plot domain */
-declare const Frame: import("svelte").Component<FrameMarkProps, {}, "">;
-type Frame = ReturnType<typeof Frame>;
+declare const Frame: $$IsomorphicComponent;
+type Frame<Datum extends DataRecord> = InstanceType<typeof Frame<Datum>>;
 export default Frame;