svelteplot 0.2.6-next.5 → 0.2.6-pr-67.0

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

@@ -1,5 +1,4 @@
-import type { BaseMarkProps, RawValue, ConstantAccessor } from '../types.js';
-type AxisXProps = BaseMarkProps & {
+export type AxisXMarkProps = Omit<BaseMarkProps, 'fill' | 'fillOpacity' | 'paintOrder' | 'title' | 'href' | 'target'> & {
     data?: RawValue[];
     automatic?: boolean;
     title?: string;
@@ -13,6 +12,8 @@ type AxisXProps = BaseMarkProps & {
     tickFormat?: 'auto' | Intl.DateTimeFormatOptions | Intl.NumberFormatOptions | ((d: RawValue) => string);
     tickClass?: ConstantAccessor<string>;
 };
-declare const AxisX: import("svelte").Component<AxisXProps, {}, "">;
+import type { BaseMarkProps, RawValue, ConstantAccessor } from '../types.js';
+/** Renders a horizontal axis with labels and tick marks */
+declare const AxisX: import("svelte").Component<AxisXMarkProps, {}, "">;
 type AxisX = ReturnType<typeof AxisX>;
 export default AxisX;

package/dist/marks/AxisY.svelte

@@ -1,3 +1,31 @@
+<!-- @component
+    Renders a vertical axis with labels and tick marks
+-->
+<script module lang="ts">
+    export type AxisYMarkProps = Omit<
+        BaseMarkProps,
+        'fill' | 'fillOpacity' | 'paintOrder' | 'title' | 'href' | 'target'
+    > & {
+        data?: RawValue[];
+        automatic?: boolean;
+        title?: string;
+        anchor?: 'left' | 'right';
+        facetAnchor?: 'auto' | 'left' | 'right' | 'left-empty' | 'right-empty';
+        lineAnchor?: 'top' | 'center' | 'bottom';
+        interval?: string | number;
+        labelAnchor?: 'auto' | 'left' | 'center' | 'right';
+        tickSize?: number;
+        tickFontSize?: ConstantAccessor<number>;
+        tickPadding?: number;
+        tickFormat?:
+            | 'auto'
+            | Intl.DateTimeFormatOptions
+            | Intl.NumberFormatOptions
+            | ((d: RawValue) => string);
+        tickClass?: ConstantAccessor<string>;
+    };
+</script>
+
 <script lang="ts">
     import { getContext } from 'svelte';
     import BaseAxisY from './helpers/BaseAxisY.svelte';
@@ -22,29 +50,11 @@
         ...getContext<Partial<DefaultOptions>>('svelteplot/_defaults')
     };
 
-    type AxisYProps = BaseMarkProps & {
-        data?: RawValue[];
-        automatic?: boolean;
-        title?: string;
-        anchor?: 'left' | 'right';
-        facetAnchor?: 'auto' | 'left' | 'right' | 'left-empty' | 'right-empty';
-        lineAnchor?: 'top' | 'center' | 'bottom';
-        tickSize?: number;
-        tickFontSize?: ConstantAccessor<number>;
-        tickPadding?: number;
-        tickFormat?:
-            | 'auto'
-            | Intl.DateTimeFormatOptions
-            | Intl.NumberFormatOptions
-            | ((d: RawValue) => string);
-        tickClass?: ConstantAccessor<string>;
-    };
-
     let {
         data = [],
         automatic = false,
         title,
-        anchor = DEFAULTS.axisYAnchor,
+        anchor = DEFAULTS.axisYAnchor as 'left' | 'right',
         facetAnchor = 'auto',
         lineAnchor = 'center',
         tickSize = DEFAULTS.tickSize,
@@ -53,7 +63,7 @@
         tickFormat,
         tickClass,
         ...options
-    }: AxisYProps = $props();
+    }: AxisYMarkProps = $props();
 
     const { getPlotState } = getContext<PlotContext>('svelteplot');
     const plot = $derived(getPlotState());
@@ -120,17 +130,15 @@
         facetAnchor !== 'auto' ? facetAnchor : anchor === 'left' ? 'left-empty' : 'right-empty'
     );
 
-    let showAxis = $state(false);
-    $effect.pre(() => {
-        showAxis =
-            useFacetAnchor === 'left'
-                ? left
-                : useFacetAnchor === 'right'
-                  ? right
-                  : useFacetAnchor === 'left-empty'
-                    ? leftEmpty
-                    : rightEmpty;
-    });
+    const showAxis = $state(
+        useFacetAnchor === 'left'
+            ? left
+            : useFacetAnchor === 'right'
+              ? right
+              : useFacetAnchor === 'left-empty'
+                ? leftEmpty
+                : rightEmpty
+    );
 </script>
 
 <Mark

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

@@ -1,18 +1,21 @@
-import type { BaseMarkProps, RawValue } from '../types.js';
-import type { ConstantAccessor } from '../types.js';
-type AxisYProps = BaseMarkProps & {
+export type AxisYMarkProps = Omit<BaseMarkProps, 'fill' | 'fillOpacity' | 'paintOrder' | 'title' | 'href' | 'target'> & {
     data?: RawValue[];
     automatic?: boolean;
     title?: string;
     anchor?: 'left' | 'right';
     facetAnchor?: 'auto' | 'left' | 'right' | 'left-empty' | 'right-empty';
     lineAnchor?: 'top' | 'center' | 'bottom';
+    interval?: string | number;
+    labelAnchor?: 'auto' | 'left' | 'center' | 'right';
     tickSize?: number;
     tickFontSize?: ConstantAccessor<number>;
     tickPadding?: number;
     tickFormat?: 'auto' | Intl.DateTimeFormatOptions | Intl.NumberFormatOptions | ((d: RawValue) => string);
     tickClass?: ConstantAccessor<string>;
 };
-declare const AxisY: import("svelte").Component<AxisYProps, {}, "">;
+import type { BaseMarkProps, RawValue } from '../types.js';
+import type { ConstantAccessor } from '../types.js';
+/** Renders a vertical axis with labels and tick marks */
+declare const AxisY: import("svelte").Component<AxisYMarkProps, {}, "">;
 type AxisY = ReturnType<typeof AxisY>;
 export default AxisY;

package/dist/marks/BarX.svelte

@@ -2,26 +2,41 @@
     @component
     For horizontal bar charts using a band scale as y axis
 -->
+<script module lang="ts">
+    import type {
+        PlotContext,
+        BaseMarkProps,
+        BaseRectMarkProps,
+        ChannelAccessor
+    } from '../types.js';
+
+    export type BarXMarkProps = BaseMarkProps &
+        BaseRectMarkProps & {
+            data: DataRow[];
+            x?: ChannelAccessor;
+            x1?: ChannelAccessor;
+            x2?: ChannelAccessor;
+            y?: ChannelAccessor;
+            stack?: StackOptions;
+            /**
+             * Converts x into x1/x2 ranges based on the provided interval. Disables the
+             * implicit stacking
+             */
+            interval?: number | string;
+        };
+</script>
+
 <script lang="ts">
     import Mark from '../Mark.svelte';
     import { getContext } from 'svelte';
     import { stackX, recordizeX, intervalX, sort } from '../index.js';
-    import type { PlotContext, BaseMarkProps, RectMarkProps, ChannelAccessor } from '../types.js';
+
     import type { StackOptions } from '../transforms/stack.js';
     import type { DataRow } from '../types.js';
     import GroupMultiple from './helpers/GroupMultiple.svelte';
     import RectPath from './helpers/RectPath.svelte';
 
-    type BarXProps = BaseMarkProps & {
-        data: DataRow[];
-        x?: ChannelAccessor;
-        x1?: ChannelAccessor;
-        x2?: ChannelAccessor;
-        y?: ChannelAccessor;
-        stack?: StackOptions;
-    } & RectMarkProps;
-
-    let { data = [{}], class: className = null, stack, ...options }: BarXProps = $props();
+    let { data = [{}], class: className = null, stack, ...options }: BarXMarkProps = $props();
 
     const { getPlotState } = getContext<PlotContext>('svelteplot');
     const plot = $derived(getPlotState());
@@ -45,7 +60,7 @@
     {...args}>
     {#snippet children({ mark, usedScales, scaledData })}
         <GroupMultiple class="bar-x" length={scaledData.length}>
-            {#each scaledData as d}
+            {#each scaledData as d, i (i)}
                 {@const bw = plot.scales.y.fn.bandwidth()}
                 {@const minx = Math.min(d.x1, d.x2)}
                 {@const maxx = Math.max(d.x1, d.x2)}

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

@@ -1,4 +1,20 @@
+import type { BaseMarkProps, BaseRectMarkProps, ChannelAccessor } from '../types.js';
+export type BarXMarkProps = BaseMarkProps & BaseRectMarkProps & {
+    data: DataRow[];
+    x?: ChannelAccessor;
+    x1?: ChannelAccessor;
+    x2?: ChannelAccessor;
+    y?: ChannelAccessor;
+    stack?: StackOptions;
+    /**
+     * Converts x into x1/x2 ranges based on the provided interval. Disables the
+     * implicit stacking
+     */
+    interval?: number | string;
+};
+import type { StackOptions } from '../transforms/stack.js';
+import type { DataRow } from '../types.js';
 /** For horizontal bar charts using a band scale as y axis */
-declare const BarX: import("svelte").Component<any, {}, "">;
+declare const BarX: import("svelte").Component<BarXMarkProps, {}, "">;
 type BarX = ReturnType<typeof BarX>;
 export default BarX;

package/dist/marks/BarY.svelte

@@ -2,16 +2,16 @@
     @component
     For vertical column charts using a band scale as x axis
 -->
-<script lang="ts">
-    import Mark from '../Mark.svelte';
-    import { getContext } from 'svelte';
-    import { intervalY, stackY, recordizeY, sort } from '../index.js';
-    import type { PlotContext, BaseMarkProps, BaseRectMarkProps } from '../types.js';
-    import type { StackOptions } from '../transforms/stack.js';
-    import GroupMultiple from './helpers/GroupMultiple.svelte';
-    import RectPath from './helpers/RectPath.svelte';
+<script module lang="ts">
+    import type {
+        PlotContext,
+        BaseMarkProps,
+        BaseRectMarkProps,
+        ChannelAccessor,
+        DataRow
+    } from '../types.js';
 
-    type BarYProps = BaseMarkProps &
+    export type BarYMarkProps = BaseMarkProps &
         BaseRectMarkProps & {
             data: DataRow[];
             x?: ChannelAccessor;
@@ -25,8 +25,18 @@
              */
             interval?: number | string;
         };
+</script>
+
+<script lang="ts">
+    import Mark from '../Mark.svelte';
+    import { getContext } from 'svelte';
+    import { intervalY, stackY, recordizeY, sort } from '../index.js';
+
+    import type { StackOptions } from '../transforms/stack.js';
+    import GroupMultiple from './helpers/GroupMultiple.svelte';
+    import RectPath from './helpers/RectPath.svelte';
 
-    let { data = [{}], class: className = null, stack, ...options }: BarYProps = $props();
+    let { data = [{}], class: className = null, stack, ...options }: BarYMarkProps = $props();
 
     const { getPlotState } = getContext<PlotContext>('svelteplot');
     const plot = $derived(getPlotState());
@@ -50,7 +60,7 @@
     {...args}>
     {#snippet children({ scaledData, usedScales })}
         <GroupMultiple class="bar-y" length={scaledData.length}>
-            {#each scaledData as d}
+            {#each scaledData as d, i (i)}
                 {@const bw = plot.scales.x.fn.bandwidth()}
                 {@const miny = Math.min(d.y1, d.y2)}
                 {@const maxy = Math.max(d.y1, d.y2)}

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

@@ -1,6 +1,5 @@
-import type { BaseMarkProps, BaseRectMarkProps } from '../types.js';
-import type { StackOptions } from '../transforms/stack.js';
-type BarYProps = BaseMarkProps & BaseRectMarkProps & {
+import type { BaseMarkProps, BaseRectMarkProps, ChannelAccessor, DataRow } from '../types.js';
+export type BarYMarkProps = BaseMarkProps & BaseRectMarkProps & {
     data: DataRow[];
     x?: ChannelAccessor;
     y?: ChannelAccessor;
@@ -13,7 +12,8 @@ type BarYProps = BaseMarkProps & BaseRectMarkProps & {
      */
     interval?: number | string;
 };
+import type { StackOptions } from '../transforms/stack.js';
 /** For vertical column charts using a band scale as x axis */
-declare const BarY: import("svelte").Component<BarYProps, {}, "">;
+declare const BarY: import("svelte").Component<BarYMarkProps, {}, "">;
 type BarY = ReturnType<typeof BarY>;
 export default BarY;

package/dist/marks/BollingerX.svelte

@@ -2,12 +2,8 @@
     @component
     line representing a moving average and an area representing volatility as a band
 -->
-<script lang="ts">
-    import { Area, Line, bollingerX, recordizeX } from '../index.js';
-    import type { BaseMarkProps, ChannelAccessor, DataRow } from '../types.js';
-    import { pick } from 'es-toolkit';
-
-    type BollingerXProps = BaseMarkProps & {
+<script module lang="ts">
+    export type BollingerXMarkProps = BaseMarkProps & {
         data: DataRow[];
         x?: ChannelAccessor;
         y?: ChannelAccessor;
@@ -20,8 +16,20 @@
          */
         k?: number;
     };
+</script>
+
+<script lang="ts">
+    import { Area, Line, bollingerX, recordizeX } from '../index.js';
+    import type { BaseMarkProps, ChannelAccessor, DataRow } from '../types.js';
+    import { pick } from 'es-toolkit';
 
-    let { data, class: className = null, n = 20, k = 2, ...options }: BollingerXProps = $props();
+    let {
+        data,
+        class: className = null,
+        n = 20,
+        k = 2,
+        ...options
+    }: BollingerXMarkProps = $props();
 
     let args = $derived(bollingerX(recordizeX({ data, ...options }), { n, k }));
 </script>

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

@@ -1,5 +1,4 @@
-import type { BaseMarkProps, ChannelAccessor, DataRow } from '../types.js';
-type BollingerXProps = BaseMarkProps & {
+export type BollingerXMarkProps = BaseMarkProps & {
     data: DataRow[];
     x?: ChannelAccessor;
     y?: ChannelAccessor;
@@ -12,7 +11,8 @@ type BollingerXProps = BaseMarkProps & {
      */
     k?: number;
 };
+import type { BaseMarkProps, ChannelAccessor, DataRow } from '../types.js';
 /** line representing a moving average and an area representing volatility as a band */
-declare const BollingerX: import("svelte").Component<BollingerXProps, {}, "">;
+declare const BollingerX: import("svelte").Component<any, {}, "">;
 type BollingerX = ReturnType<typeof BollingerX>;
 export default BollingerX;

package/dist/marks/BollingerY.svelte

@@ -2,12 +2,8 @@
     @component
     line representing a moving average and an area representing volatility as a band
 -->
-<script lang="ts">
-    import { Area, Line, bollingerY, recordizeY } from '../index.js';
-    import type { BaseMarkProps, ChannelAccessor, DataRow } from '../types.js';
-    import { pick } from 'es-toolkit';
-
-    type BollingerYProps = BaseMarkProps & {
+<script module lang="ts">
+    export type BollingerYMarkProps = BaseMarkProps & {
         data: DataRow[];
         x?: ChannelAccessor;
         y?: ChannelAccessor;
@@ -20,8 +16,14 @@
          */
         k?: number;
     };
+</script>
+
+<script lang="ts">
+    import { Area, Line, bollingerY, recordizeY } from '../index.js';
+    import type { BaseMarkProps, ChannelAccessor, DataRow } from '../types.js';
+    import { pick } from 'es-toolkit';
 
-    let { data, n = 20, k = 2, class: className, ...options }: BollingerYProps = $props();
+    let { data, n = 20, k = 2, class: className, ...options }: BollingerYMarkProps = $props();
 
     const args = $derived(bollingerY(recordizeY({ data, ...options }), { n, k }));
 </script>

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

@@ -1,5 +1,4 @@
-import type { BaseMarkProps, ChannelAccessor, DataRow } from '../types.js';
-type BollingerYProps = BaseMarkProps & {
+export type BollingerYMarkProps = BaseMarkProps & {
     data: DataRow[];
     x?: ChannelAccessor;
     y?: ChannelAccessor;
@@ -12,7 +11,8 @@ type BollingerYProps = BaseMarkProps & {
      */
     k?: number;
 };
+import type { BaseMarkProps, ChannelAccessor, DataRow } from '../types.js';
 /** line representing a moving average and an area representing volatility as a band */
-declare const BollingerY: import("svelte").Component<BollingerYProps, {}, "">;
+declare const BollingerY: import("svelte").Component<any, {}, "">;
 type BollingerY = ReturnType<typeof BollingerY>;
 export default BollingerY;

package/dist/marks/BoxX.svelte

@@ -1,3 +1,6 @@
+<!-- @component
+    Creates a horizontal box plot for visualizing data distribution with quartiles and outliers
+-->
 <script lang="ts">
     import GroupMultiple from './helpers/GroupMultiple.svelte';
     import type { BoxProps } from './BoxY.svelte';

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

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

package/dist/marks/BoxY.svelte

@@ -1,3 +1,6 @@
+<!-- @component
+    Creates a vertical box plot for visualizing data distribution with quartiles and outliers
+-->
 <script lang="ts" module>
     export type BoxProps = {
         data: DataRecord[];

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

@@ -24,6 +24,7 @@ export type BoxProps = {
     dot: Record<string, ChannelAccessor>;
 };
 import type { ChannelAccessor, DataRecord } from '../types.js';
+/** Creates a vertical box plot for visualizing data distribution with quartiles and outliers */
 declare const BoxY: import("svelte").Component<BoxProps, {}, "">;
 type BoxY = ReturnType<typeof BoxY>;
 export default BoxY;

package/dist/marks/BrushX.svelte

@@ -1,7 +1,11 @@
+<script module type="ts">
+    export type BrushXMarkProps = Omit<BrushMarkProps, 'limitDimension'>;
+</script>
+
 <script lang="ts">
     import Brush, { type BrushMarkProps } from './Brush.svelte';
 
-    let { brush, ...restProps }: Omit<BrushMarkProps, 'limitDimension'> = $props();
+    let { brush, ...restProps }: BrushXMarkProps = $props();
 </script>
 
 <Brush bind:brush limitDimension="x" {...restProps} />

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

@@ -1,4 +1,5 @@
+export type BrushXMarkProps = Omit<BrushMarkProps, 'limitDimension'>;
 import { type BrushMarkProps } from './Brush.svelte';
-declare const BrushX: import("svelte").Component<Omit<BrushMarkProps, "limitDimension">, {}, "">;
+declare const BrushX: import("svelte").Component<BrushXMarkProps, {}, "">;
 type BrushX = ReturnType<typeof BrushX>;
 export default BrushX;

package/dist/marks/BrushY.svelte

@@ -1,7 +1,11 @@
+<script module type="ts">
+    export type BrushYMarkProps = Omit<BrushMarkProps, 'limitDimension'>;
+</script>
+
 <script lang="ts">
     import Brush, { type BrushMarkProps } from './Brush.svelte';
 
-    let { brush, ...restProps }: Omit<BrushMarkProps, 'limitDimension'> = $props();
+    let { brush, ...restProps }: BrushYMarkProps = $props();
 </script>
 
 <Brush bind:brush limitDimension="y" {...restProps} />

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

@@ -1,4 +1,5 @@
+export type BrushYMarkProps = Omit<BrushMarkProps, 'limitDimension'>;
 import { type BrushMarkProps } from './Brush.svelte';
-declare const BrushY: import("svelte").Component<Omit<BrushMarkProps, "limitDimension">, {}, "">;
+declare const BrushY: import("svelte").Component<BrushYMarkProps, {}, "">;
 type BrushY = ReturnType<typeof BrushY>;
 export default BrushY;

package/dist/marks/Cell.svelte

@@ -2,11 +2,7 @@
     @component
     For arbitrary rectangles, requires band x and y scales 
 -->
-<script lang="ts">
-    import Mark from '../Mark.svelte';
-    import { getContext } from 'svelte';
-    import { recordizeY, sort } from '../index.js';
-    import { resolveChannel } from '../helpers/resolve.js';
+<script module lang="ts">
     import type {
         PlotContext,
         DataRecord,
@@ -14,24 +10,25 @@
         BaseRectMarkProps,
         ChannelAccessor
     } from '../types.js';
+
+    export type CellMarkProps = BaseMarkProps &
+        BaseRectMarkProps & {
+            data: DataRecord[];
+            x?: ChannelAccessor;
+            y?: ChannelAccessor;
+        };
+</script>
+
+<script lang="ts">
+    import Mark from '../Mark.svelte';
+    import { getContext } from 'svelte';
+    import { recordizeY, sort } from '../index.js';
+    import { resolveChannel } from '../helpers/resolve.js';
+
     import { isValid } from '../helpers/isValid.js';
     import RectPath from './helpers/RectPath.svelte';
 
-    type CellProps = BaseMarkProps & {
-        data: DataRecord[];
-        x?: ChannelAccessor;
-        y?: ChannelAccessor;
-        borderRadius?:
-            | number
-            | {
-                  topLeft?: number;
-                  topRight?: number;
-                  bottomRight?: number;
-                  bottomLeft?: number;
-              };
-    } & BaseRectMarkProps;
-
-    let { data = [{}], class: className = null, ...options }: CellProps = $props();
+    let { data = [{}], class: className = null, ...options }: CellMarkProps = $props();
 
     const { getPlotState } = getContext<PlotContext>('svelteplot');
     const plot = $derived(getPlotState());
@@ -61,7 +58,7 @@
         {@const bwx = plot.scales.x.fn.bandwidth()}
         {@const bwy = plot.scales.y.fn.bandwidth()}
         <g class="cell {className || ''}" data-fill={usedScales.fillOpacity}>
-            {#each scaledData as d}
+            {#each scaledData as d, i (i)}
                 {#if d.valid && (args.fill == null || isValid(resolveChannel('fill', d.datum, args)))}
                     <RectPath
                         datum={d}

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

@@ -1,16 +1,10 @@
 import type { DataRecord, BaseMarkProps, BaseRectMarkProps, ChannelAccessor } from '../types.js';
-type CellProps = BaseMarkProps & {
+export type CellMarkProps = BaseMarkProps & BaseRectMarkProps & {
     data: DataRecord[];
     x?: ChannelAccessor;
     y?: ChannelAccessor;
-    borderRadius?: number | {
-        topLeft?: number;
-        topRight?: number;
-        bottomRight?: number;
-        bottomLeft?: number;
-    };
-} & BaseRectMarkProps;
+};
 /** For arbitrary rectangles, requires band x and y scales */
-declare const Cell: import("svelte").Component<CellProps, {}, "">;
+declare const Cell: import("svelte").Component<CellMarkProps, {}, "">;
 type Cell = ReturnType<typeof Cell>;
 export default Cell;

package/dist/marks/CellX.svelte

@@ -1,20 +1,15 @@
+<script module lang="ts">
+    export type CellXMarkProps = Omit<CellMarkProps, 'y'>;
+</script>
+
 <script lang="ts">
-    import Cell from './Cell.svelte';
+    import Cell, { type CellMarkProps } from './Cell.svelte';
     import { recordizeY } from '../index.js';
-    import type { BaseMarkProps, DataRow, RectMarkProps } from '../types.js';
-    import type { ChannelAccessor } from '../types.js';
-
-    type CellXProps = BaseMarkProps & {
-        data: DataRow[];
-        x?: ChannelAccessor;
-        fill?: ChannelAccessor;
-        stroke?: ChannelAccessor;
-    } & RectMarkProps;
 
-    let { data = [{}], ...options }: CellXProps = $props();
+    let { data = [{}], ...options }: CellXMarkProps = $props();
 
     const args = $derived(
-        recordizeY<CellXProps>({
+        recordizeY<CellXMarkProps>({
             data,
             ...options
         })

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

@@ -1,3 +1,5 @@
-declare const CellX: import("svelte").Component<any, {}, "">;
+export type CellXMarkProps = Omit<CellMarkProps, 'y'>;
+import { type CellMarkProps } from './Cell.svelte';
+declare const CellX: import("svelte").Component<CellXMarkProps, {}, "">;
 type CellX = ReturnType<typeof CellX>;
 export default CellX;

package/dist/marks/CellY.svelte

@@ -1,20 +1,15 @@
+<script module lang="ts">
+    export type CellYMarkProps = Omit<CellMarkProps, 'x'>;
+</script>
+
 <script lang="ts">
-    import Cell from './Cell.svelte';
+    import Cell, { type CellMarkProps } from './Cell.svelte';
     import { recordizeX } from '../index.js';
-    import type { BaseMarkProps, DataRow, RectMarkProps } from '../types.js';
-    import type { ChannelAccessor } from '../types.js';
-
-    type CellYProps = BaseMarkProps & {
-        data: DataRow[];
-        y?: ChannelAccessor;
-        fill?: ChannelAccessor;
-        stroke?: ChannelAccessor;
-    } & RectMarkProps;
 
-    let { data = [{}], ...options }: CellYProps = $props();
+    let { data = [{}], ...options }: CellYMarkProps = $props();
 
     const args = $derived(
-        recordizeX<CellYProps>({
+        recordizeX<CellYMarkProps>({
             data,
             ...options
         })

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

@@ -1,3 +1,5 @@
-declare const CellY: import("svelte").Component<any, {}, "">;
+export type CellYMarkProps = Omit<CellMarkProps, 'x'>;
+import { type CellMarkProps } from './Cell.svelte';
+declare const CellY: import("svelte").Component<CellYMarkProps, {}, "">;
 type CellY = ReturnType<typeof CellY>;
 export default CellY;