svelteplot 0.2.7 → 0.2.8-pr-68.0

package/dist/Plot.svelte

@@ -91,89 +91,101 @@
 <!-- There's a bug triggering RangeError: Maximum call stack size exceeded 
      when using SveltePlot in ssr, so for now, we're disabling it -->
 
-<Plot
-    {overlay}
-    {underlay}
-    {...restOptions}
-    header={userHeader ||
-    restOptions.title ||
-    restOptions.subtitle ||
-    restOptions.color?.legend ||
-    restOptions.symbol?.legend
-        ? header
-        : null}
-    footer={userFooter || restOptions?.caption ? footer : null}
-    projection={projectionOpts}
-    implicitScales
-    {...scales}>
-    {#snippet children({
-        hasProjection,
-        hasExplicitAxisX,
-        hasExplicitAxisY,
-        hasExplicitGridX,
-        hasExplicitGridY,
-        options,
-        scales,
-        ...restProps
-    })}
-        <svelte:boundary onerror={(err) => console.warn(err)}>
-            <!-- implicit axes -->
-            {#if !hasProjection && !hasExplicitAxisX}
-                {#if options.axes && (options.x.axis === 'top' || options.x.axis === 'both')}
-                    <AxisX anchor="top" automatic />
+<svelte:boundary>
+    <Plot
+        {overlay}
+        {underlay}
+        {...restOptions}
+        header={userHeader ||
+        restOptions.title ||
+        restOptions.subtitle ||
+        restOptions.color?.legend ||
+        restOptions.symbol?.legend
+            ? header
+            : null}
+        footer={userFooter || restOptions?.caption ? footer : null}
+        projection={projectionOpts}
+        implicitScales
+        {...scales}>
+        {#snippet children({
+            hasProjection,
+            hasExplicitAxisX,
+            hasExplicitAxisY,
+            hasExplicitGridX,
+            hasExplicitGridY,
+            options,
+            scales,
+            ...restProps
+        })}
+            <svelte:boundary onerror={(err) => console.warn(err)}>
+                <!-- implicit axes -->
+                {#if !hasProjection && !hasExplicitAxisX}
+                    {#if options.axes && (options.x.axis === 'top' || options.x.axis === 'both')}
+                        <AxisX anchor="top" automatic />
+                    {/if}
+                    {#if options.axes && (options.x.axis === 'bottom' || options.x.axis === 'both')}
+                        <AxisX anchor="bottom" automatic />
+                    {/if}
                 {/if}
-                {#if options.axes && (options.x.axis === 'bottom' || options.x.axis === 'both')}
-                    <AxisX anchor="bottom" automatic />
+                {#if !hasProjection && !hasExplicitAxisY}
+                    {#if options.axes && (options.y.axis === 'left' || options.y.axis === 'both')}
+                        <AxisY anchor="left" automatic />
+                    {/if}
+                    {#if options.axes && (options.y.axis === 'right' || options.y.axis === 'both')}
+                        <AxisY anchor="right" automatic />
+                    {/if}
                 {/if}
-            {/if}
-            {#if !hasProjection && !hasExplicitAxisY}
-                {#if options.axes && (options.y.axis === 'left' || options.y.axis === 'both')}
-                    <AxisY anchor="left" automatic />
+                <!-- implicit grids -->
+                {#if !hasExplicitGridX && (options.grid || options.x.grid)}
+                    <GridX automatic />
                 {/if}
-                {#if options.axes && (options.y.axis === 'right' || options.y.axis === 'both')}
-                    <AxisY anchor="right" automatic />
+                {#if !hasExplicitGridY && (options.grid || options.y.grid)}
+                    <GridY automatic />
                 {/if}
-            {/if}
-            <!-- implicit grids -->
-            {#if !hasExplicitGridX && (options.grid || options.x.grid)}
-                <GridX automatic />
-            {/if}
-            {#if !hasExplicitGridY && (options.grid || options.y.grid)}
-                <GridY automatic />
-            {/if}
-            <!-- implicit frame -->
-            {#if options.frame}
-                <Frame automatic />
-            {/if}
-            {@render parentChildren?.({
-                options,
-                scales,
-                ...restProps
-            })}
-            {#snippet failed(error, reset)}
-                <text class="error" transform="translate(10,10)">
-                    {#each error.message.split('\n') as line, i (i)}
-                        <tspan x="0" dy={i ? 14 : 0}>{line}</tspan>
-                    {/each}
-                </text>{/snippet}
-        </svelte:boundary>
-    {/snippet}
-    {#snippet facetAxes()}
-        <FacetAxes />
+                <!-- implicit frame -->
+                {#if options.frame}
+                    <Frame automatic />
+                {/if}
+                {@render parentChildren?.({
+                    options,
+                    scales,
+                    ...restProps
+                })}
+                {#snippet failed(error, reset)}
+                    <text class="error" transform="translate(10,10)">
+                        {#each error.message.split('\n') as line, i (i)}
+                            <tspan x="0" dy={i ? 14 : 0}>{line}</tspan>
+                        {/each}
+                    </text>{/snippet}
+            </svelte:boundary>
+        {/snippet}
+        {#snippet facetAxes()}
+            <FacetAxes />
+        {/snippet}
+    </Plot>
+    {#snippet failed(error)}
+        <div class="error">Error: {error.message}</div>
     {/snippet}
-</Plot>
+</svelte:boundary>
 
 <style>
     :root {
         --plot-bg: white;
         --plot-fg: currentColor;
     }
-    text.error {
-        stroke: var(--plot-bg);
-        fill: crimson;
+    .error {
         font-size: 11px;
         stroke-width: 3px;
         font-weight: bold;
+    }
+    text.error {
+        stroke: var(--plot-bg);
+        fill: crimson;
         paint-order: stroke fill;
     }
+    div.error {
+        color: crimson;
+        white-space: pre-wrap;
+        line-height: 1.1;
+    }
 </style>

package/dist/helpers/autoTicks.js

@@ -1,5 +1,5 @@
 import { maybeTimeInterval } from './time.js';
-import { range as rangei } from 'd3-array';
+import { extent, range as rangei } from 'd3-array';
 export function maybeInterval(interval) {
     if (interval == null)
         return;
@@ -30,11 +30,12 @@ export function maybeInterval(interval) {
     return interval;
 }
 export function autoTicks(type, ticks, interval, domain, scaleFn, count) {
-    return ticks
-        ? ticks
-        : interval
-            ? maybeInterval(interval, type).range(domain[0], domain[1])
-            : typeof scaleFn.ticks === 'function'
-                ? scaleFn.ticks(count)
-                : [];
+    if (ticks)
+        return ticks;
+    if (interval) {
+        const [lo, hi] = extent(domain);
+        const I = maybeInterval(interval, type);
+        return I.range(lo, I.offset(hi));
+    }
+    return typeof scaleFn.ticks === 'function' ? scaleFn.ticks(count) : [];
 }

package/dist/helpers/colors.d.ts

@@ -6,7 +6,7 @@ type SchemeGetter = (n: number) => readonly string[];
 export declare function isOrdinalScheme(scheme: ColorScheme): boolean;
 export declare function ordinalScheme(scheme: string): SchemeGetter | undefined;
 export declare function ordinalRange(scheme: string, length: number): readonly string[] | undefined;
-export declare function maybeBooleanRange(domain: boolean[], scheme?: string): unknown[] | undefined;
+export declare function maybeBooleanRange(domain: boolean[], scheme?: string): any[] | undefined;
 export declare function isQuantitativeScheme(scheme: string): boolean;
 export declare function quantitativeScheme(scheme: string): typeof interpolateBrBG | undefined;
 export declare function isDivergingScheme(scheme: string): boolean;

package/dist/helpers/index.d.ts

@@ -3,8 +3,8 @@ import type { Snippet } from 'svelte';
 /**
  * Returns first argument that is not null or undefined
  */
-export declare function coalesce(...args: (RawValue | undefined | null)[]): RawValue | null;
-export declare function testFilter(datum: DataRecord, options: Record<ChannelName, ChannelAccessor>): string | number | boolean | symbol | Date | null;
+export declare function coalesce(...args: (RawValue | undefined | null)[]): any;
+export declare function testFilter(datum: DataRecord, options: Record<ChannelName, ChannelAccessor>): any;
 export declare function randomId(): string;
 export declare function isSnippet(value: unknown): value is Snippet;
 export declare function isValid(value: RawValue | undefined): value is number | Date | string;

package/dist/helpers/scales.d.ts

@@ -15,7 +15,7 @@ export declare function createScale<T extends ScaleOptions>(name: ScaleName, sca
     autoTitle?: undefined;
 } | {
     type: ScaleType;
-    domain: RawValue[] | [undefined, undefined];
+    domain: any;
     range: any;
     fn: any;
     skip: Map<ScaledChannelName, Set<symbol>>;

package/dist/helpers/scales.js

@@ -5,6 +5,7 @@ import { isSymbolOrNull } from './typeChecks.js';
 import { resolveProp, toChannelOption } from './resolve.js';
 import isDataRecord from './isDataRecord.js';
 import { createProjection } from './projection.js';
+import { maybeInterval } from './autoTicks.js';
 /**
  * compute the plot scales
  */
@@ -148,7 +149,7 @@ export function createScale(name, scaleOptions, marks, plotOptions, plotWidth, p
         valueArr.sort(ascending);
     }
     const valueArray = type === 'quantile' || type === 'quantile-cont' ? allDataValues.toSorted() : valueArr;
-    const domain = scaleOptions.domain
+    let domain = scaleOptions.domain
         ? isOrdinal
             ? scaleOptions.domain
             : extent(scaleOptions.zero ? [0, ...scaleOptions.domain] : scaleOptions.domain)
@@ -162,6 +163,14 @@ export function createScale(name, scaleOptions, marks, plotOptions, plotWidth, p
                 ? valueArray.toReversed()
                 : valueArray
             : extent(scaleOptions.zero ? [0, ...valueArray] : valueArray);
+    if (scaleOptions.interval) {
+        if (isOrdinal) {
+            domain = domainFromInterval(domain, scaleOptions.interval);
+        }
+        else {
+            throw new Error('Setting interval via axis options is only supported for ordinal scales');
+        }
+    }
     if (!scaleOptions.scale) {
         throw new Error(`No scale function defined for ${name}`);
     }
@@ -192,6 +201,11 @@ export function createScale(name, scaleOptions, marks, plotOptions, plotWidth, p
                 : null
     };
 }
+function domainFromInterval(domain, interval) {
+    const interval_ = maybeInterval(interval);
+    const [lo, hi] = extent(domain);
+    return interval_.range(lo, interval_.offset(hi));
+}
 /**
  * Infer a scale type based on the scale name, the data values mapped to it and
  * the mark types that are bound to the scale

package/dist/helpers/typeChecks.d.ts

@@ -1,10 +1,10 @@
 import type { RawValue } from '../types.js';
-export declare function isBooleanOrNull(v: RawValue): v is boolean;
+export declare function isBooleanOrNull(v: RawValue): boolean;
 export declare function isDate(v: RawValue): v is Date;
-export declare function isDateOrNull(v: RawValue | null | undefined): v is Date | null | undefined;
+export declare function isDateOrNull(v: RawValue | null | undefined): boolean;
 export declare function isNumberOrNull(v: RawValue | null | undefined): boolean;
 export declare function isNumberOrNullOrNaN(v: RawValue | null | undefined): boolean;
-export declare function isStringOrNull(v: RawValue | null | undefined): v is string | null | undefined;
+export declare function isStringOrNull(v: RawValue | null | undefined): boolean;
 export declare function isSymbolOrNull(v: RawValue | null | undefined): boolean;
-export declare function isColorOrNull(v: RawValue | null | undefined): boolean;
+export declare function isColorOrNull(v: RawValue | null | undefined): any;
 export declare function isOpacityOrNull(v: RawValue): boolean;

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

@@ -13,6 +13,6 @@ export type BollingerXMarkProps = BaseMarkProps & {
 };
 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<BollingerXMarkProps, {}, "">;
+declare const BollingerX: import("svelte").Component<any, {}, "">;
 type BollingerX = ReturnType<typeof BollingerX>;
 export default BollingerX;

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

@@ -13,6 +13,6 @@ export type BollingerYMarkProps = BaseMarkProps & {
 };
 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<BollingerYMarkProps, {}, "">;
+declare const BollingerY: import("svelte").Component<any, {}, "">;
 type BollingerY = ReturnType<typeof BollingerY>;
 export default BollingerY;

package/dist/marks/ColorLegend.svelte

@@ -129,7 +129,7 @@
                 marginBottom={20}
                 height={38}
                 inset={0}
-                x={{ domain, tickSpacing, tickFormat }}>
+                x={{ domain, tickSpacing: 30, tickFormat }}>
                 <defs>
                     <linearGradient id="gradient-{randId}" x2="1">
                         {#each ticks as t (t)}

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

@@ -1,61 +1,6 @@
 import { type BaseMarkProps } from '../types.js';
 export type SphereMarkProps = BaseMarkProps;
 /** Geo mark with Sphere geometry object */
-declare const Sphere: import("svelte").Component<Partial<{
-    filter?: import("../types.js").ConstantAccessor<boolean>;
-    facet?: "auto" | "include" | "exclude";
-    fx: import("../types.js").ChannelAccessor;
-    fy: import("../types.js").ChannelAccessor;
-    dx: import("../types.js").ConstantAccessor<number>;
-    dy: import("../types.js").ConstantAccessor<number>;
-    fill: import("../types.js").ConstantAccessor<string>;
-    fillOpacity: import("../types.js").ConstantAccessor<number>;
-    stroke: import("../types.js").ConstantAccessor<string>;
-    strokeWidth: import("../types.js").ConstantAccessor<number>;
-    strokeOpacity: import("../types.js").ConstantAccessor<number>;
-    strokeLinejoin: import("../types.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin>;
-    strokeLinecap: import("../types.js").ConstantAccessor<import("csstype").Property.StrokeLinecap>;
-    strokeMiterlimit: import("../types.js").ConstantAccessor<number>;
-    opacity: import("../types.js").ConstantAccessor<number>;
-    strokeDasharray: import("../types.js").ConstantAccessor<string>;
-    strokeDashoffset: import("../types.js").ConstantAccessor<number>;
-    mixBlendMode: import("../types.js").ConstantAccessor<import("csstype").Property.MixBlendMode>;
-    clipPath: string;
-    imageFilter: import("../types.js").ConstantAccessor<string>;
-    shapeRendering: import("../types.js").ConstantAccessor<import("csstype").Property.ShapeRendering>;
-    paintOrder: import("../types.js").ConstantAccessor<string>;
-    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.js").ConstantAccessor<import("csstype").Property.Cursor>;
-}>, {}, "">;
+declare const Sphere: import("svelte").Component<BaseMarkProps, {}, "">;
 type Sphere = ReturnType<typeof Sphere>;
 export default Sphere;

package/dist/marks/helpers/CanvasLayer.svelte

@@ -2,6 +2,27 @@
     import { getContext } from 'svelte';
     import type { PlotContext } from '../../types';
     import { devicePixelRatio } from 'svelte/reactivity/window';
+    import { MediaQuery } from 'svelte/reactivity';
+    import type { Attachment } from 'svelte/attachments';
+
+    const darkMode = new MediaQuery('prefers-color-scheme: dark');
+    let colorScheme = $state();
+
+    /**
+     * we need to repaint on dark mode changes in case the user
+     * is using any css variables or currentColor that changes
+     * with the color scheme
+     */
+    const watchColorScheme: Attachment = (element: Element) => {
+        const htmlElement = element.ownerDocument.documentElement;
+        const observer = new MutationObserver(() => {
+            colorScheme = getComputedStyle(htmlElement).colorScheme;
+        });
+        observer.observe(htmlElement, { attributes: true });
+        return () => {
+            observer.disconnect();
+        };
+    };
 
     let restProps: {} = $props();
 
@@ -14,14 +35,15 @@
     canvas element inside a foreignObject for use in a plot and takes care of 
     scaling it to the device pixel ratio.
 -->
-
-<foreignObject x="0" y="0" width={plot.width} height={plot.height}>
-    <canvas
-        xmlns="http://www.w3.org/1999/xhtml"
-        {...restProps}
-        width={plot.width * (devicePixelRatio.current ?? 1)}
-        height={plot.height * (devicePixelRatio.current ?? 1)}
-        style="width: {plot.width}px; height: {plot.height}px;"></canvas>
+<foreignObject x="0" y="0" {@attach watchColorScheme} width={plot.width} height={plot.height}>
+    {#key [colorScheme, darkMode.current]}
+        <canvas
+            xmlns="http://www.w3.org/1999/xhtml"
+            {...restProps}
+            width={plot.width * (devicePixelRatio.current ?? 1)}
+            height={plot.height * (devicePixelRatio.current ?? 1)}
+            style="width: {plot.width}px; height: {plot.height}px;"></canvas>
+    {/key}
 </foreignObject>
 
 <style>

package/dist/marks/helpers/MarkerPath.svelte.d.ts

@@ -1,44 +1,4 @@
-import { type MarkerShape } from './Marker.svelte';
-import type { BaseMarkProps, ConstantAccessor, DataRecord, Mark, PlotScales } from '../../types.js';
-type MarkerPathProps = BaseMarkProps & {
-    /**
-     * the datum associated with this path, usually the first
-     * element of the data array group
-     */
-    datum: DataRecord;
-    /**
-     * the marker shape to use at the start of the path, defaults to
-     * circle
-     */
-    markerStart?: boolean | MarkerShape;
-    /**
-     * the marker shape to use at the middle of the path, defaults to circle
-     */
-    markerMid?: boolean | MarkerShape;
-    /**
-     * the marker shape to use at the end of the path, defaults to circle
-     */
-    markerEnd?: boolean | MarkerShape;
-    /**
-     * shorthand for setting all markers
-     */
-    marker?: boolean | MarkerShape;
-    /**
-     * path string
-     */
-    d: string;
-    style: string;
-    startOffset: string;
-    textStyle: string;
-    textStyleClass?: string | null;
-    text: string;
-    transform: string;
-    color: string;
-    strokeWidth: ConstantAccessor<number>;
-    mark: Mark<BaseMarkProps>;
-    scales: PlotScales;
-};
 /** Helper component for paths with markers and optional text along the path. */
-declare const MarkerPath: import("svelte").Component<MarkerPathProps, {}, "">;
+declare const MarkerPath: import("svelte").Component<any, {}, "">;
 type MarkerPath = ReturnType<typeof MarkerPath>;
 export default MarkerPath;

package/dist/transforms/bollinger.d.ts

@@ -11,11 +11,4 @@ export type BollingerOptions = {
 };
 export declare function bollingerX(args: TransformArg<DataRecord>, options?: BollingerOptions): TransformArg<DataRecord>;
 export declare function bollingerY(args: TransformArg<DataRecord>, options?: BollingerOptions): TransformArg<DataRecord>;
-export declare function bollingerDim(dim: 'x' | 'y', { data, ...channels }: TransformArg<DataRecord>, options?: BollingerOptions): {
-    data: {
-        __x: import("../types.js").RawValue;
-        __lo: number;
-        __avg: number;
-        __hi: number;
-    }[];
-};
+export declare function bollingerDim(dim: 'x' | 'y', { data, ...channels }: TransformArg<DataRecord>, options?: BollingerOptions): any;

package/dist/transforms/centroid.d.ts

@@ -1,9 +1,2 @@
 import type { DataRecord, TransformArg } from '../types.js';
-export declare function geoCentroid({ data, ...options }: TransformArg<DataRecord>): {
-    x: (d: any) => any;
-    y: (d: any) => any;
-    data: {
-        __centroid__: [number, number];
-        ___orig___?: import("../types.js").RawValue | [import("../types.js").RawValue, import("../types.js").RawValue];
-    }[];
-};
+export declare function geoCentroid({ data, ...options }: TransformArg<DataRecord>): any;

package/dist/transforms/group.d.ts

@@ -38,29 +38,21 @@ type GroupZOptions = GroupXOptions | GroupYOptions;
  * groups the dataset by x and y channel and optionally reduces the group items
  * to output channels fill, stroke, r, opacity, fillOpacity, or strokeOpacity
  */
-export declare function group({ data, ...channels }: TransformArg<T, DataRecord>, options?: GroupXOptions): {
-    data: DataRecord[];
-};
+export declare function group({ data, ...channels }: TransformArg<T, DataRecord>, options?: GroupXOptions): any;
 /**
  * groups the dataset by the x channel and optionally reduces the group items
  * to output channels y, y1, y2, fill, stroke, r, opacity, fillOpacity, or strokeOpacity
  */
-export declare function groupX(input: TransformArg<T, DataRecord>, options?: GroupXOptions): {
-    data: DataRecord[];
-};
+export declare function groupX(input: TransformArg<T, DataRecord>, options?: GroupXOptions): any;
 /**
  * groups the dataset by the y channel and optionally reduces the group items
  * to output channels x, x1, x2, fill, stroke, r, opacity, fillOpacity, or strokeOpacity
  */
-export declare function groupY(input: TransformArg<T, DataRecord>, options?: GroupYOptions): {
-    data: DataRecord[];
-};
+export declare function groupY(input: TransformArg<T, DataRecord>, options?: GroupYOptions): any;
 /**
  * groups the dataset by the z channel and optionally reduces the group items
  * to output channels x, x1, x2, y, y1, y2, fill, stroke, r, opacity, fillOpacity,
  * or strokeOpacity
  */
-export declare function groupZ(input: TransformArg<T, DataRecord>, options?: GroupZOptions): {
-    data: DataRecord[];
-};
+export declare function groupZ(input: TransformArg<T, DataRecord>, options?: GroupZOptions): any;
 export {};

package/dist/transforms/interval.d.ts

@@ -1,11 +1,7 @@
 import type { PlotState, TransformArg } from '../types.js';
 export declare function intervalX<T>(args: TransformArg<T>, { plot }: {
     plot: PlotState;
-}): {
-    data: T[];
-};
+}): any;
 export declare function intervalY<T>(args: TransformArg<T>, { plot }: {
     plot: PlotState;
-}): {
-    data: T[];
-};
+}): any;

package/dist/transforms/map.d.ts

@@ -1,10 +1,4 @@
-import type { TransformArg, MapOptions, MapMethod, DataRecord } from '../types.js';
-export declare function map<T>(args: TransformArg<T>, options: MapOptions): {
-    data: DataRecord[];
-};
-export declare function mapX<T>(args: TransformArg<T>, mapper: MapMethod): {
-    data: DataRecord[];
-};
-export declare function mapY<T>(args: TransformArg<T>, mapper: MapMethod): {
-    data: DataRecord[];
-};
+import type { TransformArg, MapOptions, MapMethod } from '../types.js';
+export declare function map<T>(args: TransformArg<T>, options: MapOptions): any;
+export declare function mapX<T>(args: TransformArg<T>, mapper: MapMethod): any;
+export declare function mapY<T>(args: TransformArg<T>, mapper: MapMethod): any;

package/dist/transforms/normalize.d.ts

@@ -1,9 +1,5 @@
 import type { TransformArg, MapIndexObject } from '../types.js';
 type NormalizeBasis = 'deviation' | 'first' | 'last' | 'min' | 'max' | 'mean' | 'median' | 'sum' | 'extent' | MapIndexObject;
-export declare function normalizeX<T>(args: TransformArg<T>, basis: NormalizeBasis): {
-    data: import("../types.js").DataRecord[];
-};
-export declare function normalizeY<T>(args: TransformArg<T>, basis: NormalizeBasis): {
-    data: import("../types.js").DataRecord[];
-};
+export declare function normalizeX<T>(args: TransformArg<T>, basis: NormalizeBasis): any;
+export declare function normalizeY<T>(args: TransformArg<T>, basis: NormalizeBasis): any;
 export {};

package/dist/transforms/select.d.ts

@@ -5,31 +5,17 @@ type AtLeastOne<T, U = {
 type SelectOptions = 'first' | 'last' | AtLeastOne<{
     [k in ChannelName]: 'min' | 'max';
 }>;
-export declare function select({ data, ...channels }: TransformArg<DataRecord>, options: SelectOptions): {
-    data: DataRecord[];
-};
+export declare function select({ data, ...channels }: TransformArg<DataRecord>, options: SelectOptions): any;
 /**
  * Keeps only the first item of each group
  */
-export declare function selectFirst(args: TransformArg<DataRecord>): {
-    data: DataRecord[];
-};
+export declare function selectFirst(args: TransformArg<DataRecord>): any;
 /**
  * Keeps only the last item of each group
  */
-export declare function selectLast(args: TransformArg<DataRecord>): {
-    data: DataRecord[];
-};
-export declare function selectMinX(args: TransformArg<DataRecord>): {
-    data: DataRecord[];
-};
-export declare function selectMaxX(args: TransformArg<DataRecord>): {
-    data: DataRecord[];
-};
-export declare function selectMinY(args: TransformArg<DataRecord>): {
-    data: DataRecord[];
-};
-export declare function selectMaxY(args: TransformArg<DataRecord>): {
-    data: DataRecord[];
-};
+export declare function selectLast(args: TransformArg<DataRecord>): any;
+export declare function selectMinX(args: TransformArg<DataRecord>): any;
+export declare function selectMaxX(args: TransformArg<DataRecord>): any;
+export declare function selectMinY(args: TransformArg<DataRecord>): any;
+export declare function selectMaxY(args: TransformArg<DataRecord>): any;
 export {};

package/dist/transforms/sort.d.ts

@@ -2,27 +2,14 @@ import type { DataRecord, DataRow, TransformArg } from '../types.js';
 export declare const SORT_KEY: unique symbol;
 export declare function sort({ data, ...channels }: TransformArg<DataRecord>, options?: {
     reverse?: boolean;
-}): {
-    sort: null;
-    data: {
-        ___orig___?: import("../types.js").RawValue | [import("../types.js").RawValue, import("../types.js").RawValue];
-    }[];
-} | {
-    data: DataRecord[];
-};
+}): any;
 /**
  * reverses the data row order
  */
 export declare function shuffle({ data, ...channels }: TransformArg<DataRow[]>, options?: {
     seed?: number;
-}): {
-    sort: null;
-    data: DataRow[][];
-};
+}): any;
 /**
  * reverses the data row order
  */
-export declare function reverse({ data, ...channels }: TransformArg<DataRow[]>): {
-    sort: null;
-    data: DataRow[][];
-};
+export declare function reverse({ data, ...channels }: TransformArg<DataRow[]>): any;

package/dist/transforms/window.d.ts

@@ -7,18 +7,6 @@ type WindowOptions = {
     reduce: ReducerName;
     strict: boolean;
 };
-export declare function windowX(args: TransformArg<DataRecord>, options: WindowOptions): {
-    data: {
-        [x: string]: import("../types.js").RawValue;
-        [x: symbol]: import("../types.js").RawValue;
-        ___orig___?: import("../types.js").RawValue | [import("../types.js").RawValue, import("../types.js").RawValue];
-    }[];
-};
-export declare function windowY(args: TransformArg<DataRecord>, options: WindowOptions): {
-    data: {
-        [x: string]: import("../types.js").RawValue;
-        [x: symbol]: import("../types.js").RawValue;
-        ___orig___?: import("../types.js").RawValue | [import("../types.js").RawValue, import("../types.js").RawValue];
-    }[];
-};
+export declare function windowX(args: TransformArg<DataRecord>, options: WindowOptions): any;
+export declare function windowY(args: TransformArg<DataRecord>, options: WindowOptions): any;
 export {};

package/package.json

@@ -1,123 +1,124 @@
 {
-  "name": "svelteplot",
-  "version": "0.2.7",
-  "license": "ISC",
-  "author": {
-    "name": "Gregor Aisch",
-    "email": "gka@users.noreply.github.com"
-  },
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "svelte": "./dist/index.js"
+    "name": "svelteplot",
+    "version": "0.2.8-pr-68.0",
+    "license": "ISC",
+    "author": {
+        "name": "Gregor Aisch",
+        "email": "gka@users.noreply.github.com"
     },
-    "./*.js": {
-      "import": "./dist/*.js"
+    "scripts": {
+        "dev": "vite dev",
+        "build": "vite build",
+        "preview": "vite preview",
+        "test": "npm run test:unit",
+        "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+        "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+        "lint": "prettier --check src && eslint src",
+        "format": "prettier --write .",
+        "test:unit": "vitest",
+        "prepack": "npx svelte-package",
+        "release-next": "npm version prerelease --preid next && npm publish && git push && git push --tags && sleep 1 && npm dist-tag add svelteplot@$(npm view . version) next",
+        "docs": "npm run build && cd build && rsync --recursive . vis4.net:svelteplot/alpha0/"
     },
-    "./*.svelte": {
-      "import": "./dist/*.svelte"
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "svelte": "./dist/index.js"
+        },
+        "./*.js": {
+            "import": "./dist/*.js"
+        },
+        "./*.svelte": {
+            "import": "./dist/*.svelte"
+        },
+        "./core/*.svelte": {
+            "import": "./dist/core/*.svelte"
+        },
+        "./marks/*.svelte": {
+            "import": "./dist/marks/*.svelte"
+        },
+        "./transforms": {
+            "import": "./dist/transforms/index.js"
+        }
     },
-    "./core/*.svelte": {
-      "import": "./dist/core/*.svelte"
+    "main": "./dist/index.js",
+    "files": [
+        "dist",
+        "!dist/**/*.test.*",
+        "!dist/**/*.spec.*"
+    ],
+    "devDependencies": {
+        "@aitodotai/json-stringify-pretty-compact": "^1.3.0",
+        "@emotion/css": "^11.13.5",
+        "@sveltejs/adapter-auto": "^6.0.1",
+        "@sveltejs/adapter-static": "^3.0.8",
+        "@sveltejs/eslint-config": "^8.2.0",
+        "@sveltejs/kit": "^2.21.1",
+        "@sveltejs/package": "^2.3.11",
+        "@sveltejs/vite-plugin-svelte": "5.0.3",
+        "@sveltepress/theme-default": "^6.0.3",
+        "@sveltepress/twoslash": "^1.2.2",
+        "@sveltepress/vite": "^1.2.2",
+        "@testing-library/svelte": "^5.2.8",
+        "@testing-library/user-event": "^14.6.1",
+        "@types/d3-array": "^3.2.1",
+        "@types/d3-color": "^3.1.3",
+        "@types/d3-dsv": "^3.0.7",
+        "@types/d3-geo": "^3.1.0",
+        "@types/d3-interpolate": "^3.0.4",
+        "@types/d3-path": "^3.1.1",
+        "@types/d3-random": "^3.0.3",
+        "@types/d3-scale": "^4.0.9",
+        "@types/d3-scale-chromatic": "^3.1.0",
+        "@types/d3-shape": "^3.1.7",
+        "@typescript-eslint/eslint-plugin": "^8.32.1",
+        "@typescript-eslint/parser": "^8.32.1",
+        "csstype": "^3.1.3",
+        "d3-dsv": "^3.0.1",
+        "d3-fetch": "^3.0.1",
+        "d3-force": "^3.0.0",
+        "eslint": "^9.27.0",
+        "eslint-config-prettier": "^10.1.5",
+        "eslint-plugin-svelte": "3.9.0",
+        "jsdom": "^26.1.0",
+        "prettier": "^3.5.3",
+        "prettier-plugin-svelte": "^3.4.0",
+        "remark-code-extra": "^1.0.1",
+        "remark-code-frontmatter": "^1.0.0",
+        "resize-observer-polyfill": "^1.5.1",
+        "sass": "^1.89.0",
+        "svelte-check": "^4.2.1",
+        "svelte-eslint-parser": "1.2.0",
+        "svelte-highlight": "^7.8.3",
+        "svg-path-parser": "^1.1.0",
+        "topojson-client": "^3.1.0",
+        "tslib": "^2.8.1",
+        "typedoc": "^0.28.5",
+        "typedoc-plugin-markdown": "^4.6.3",
+        "typescript": "^5.8.3",
+        "vite": "^6.3.5",
+        "vitest": "^3.1.4",
+        "vitest-matchmedia-mock": "^2.0.3"
     },
-    "./marks/*.svelte": {
-      "import": "./dist/marks/*.svelte"
-    },
-    "./transforms": {
-      "import": "./dist/transforms/index.js"
+    "types": "./dist/index.d.ts",
+    "type": "module",
+    "dependencies": {
+        "d3-array": "^3.2.4",
+        "d3-color": "^3.1.0",
+        "d3-format": "^3.1.0",
+        "d3-geo": "^3.1.1",
+        "d3-interpolate": "^3.0.1",
+        "d3-path": "^3.1.0",
+        "d3-quadtree": "^3.0.1",
+        "d3-random": "^3.0.1",
+        "d3-regression": "^1.3.10",
+        "d3-scale": "^4.0.2",
+        "d3-scale-chromatic": "^3.1.0",
+        "d3-shape": "^3.2.0",
+        "d3-time": "^3.1.0",
+        "es-toolkit": "^1.38.0",
+        "fast-equals": "^5.2.2",
+        "merge-deep": "^3.0.3",
+        "svelte": "5.33.2"
     }
-  },
-  "main": "./dist/index.js",
-  "files": [
-    "dist",
-    "!dist/**/*.test.*",
-    "!dist/**/*.spec.*"
-  ],
-  "devDependencies": {
-    "@aitodotai/json-stringify-pretty-compact": "^1.3.0",
-    "@emotion/css": "^11.13.5",
-    "@sveltejs/adapter-auto": "^6.0.1",
-    "@sveltejs/adapter-static": "^3.0.8",
-    "@sveltejs/eslint-config": "^8.2.0",
-    "@sveltejs/kit": "^2.21.1",
-    "@sveltejs/package": "^2.3.11",
-    "@sveltejs/vite-plugin-svelte": "5.0.3",
-    "@sveltepress/theme-default": "^6.0.3",
-    "@sveltepress/twoslash": "^1.2.2",
-    "@sveltepress/vite": "^1.2.2",
-    "@testing-library/svelte": "^5.2.8",
-    "@testing-library/user-event": "^14.6.1",
-    "@types/d3-array": "^3.2.1",
-    "@types/d3-color": "^3.1.3",
-    "@types/d3-dsv": "^3.0.7",
-    "@types/d3-geo": "^3.1.0",
-    "@types/d3-interpolate": "^3.0.4",
-    "@types/d3-path": "^3.1.1",
-    "@types/d3-random": "^3.0.3",
-    "@types/d3-scale": "^4.0.9",
-    "@types/d3-scale-chromatic": "^3.1.0",
-    "@types/d3-shape": "^3.1.7",
-    "@typescript-eslint/eslint-plugin": "^8.32.1",
-    "@typescript-eslint/parser": "^8.32.1",
-    "csstype": "^3.1.3",
-    "d3-dsv": "^3.0.1",
-    "d3-fetch": "^3.0.1",
-    "d3-force": "^3.0.0",
-    "eslint": "^9.27.0",
-    "eslint-config-prettier": "^10.1.5",
-    "eslint-plugin-svelte": "3.9.0",
-    "jsdom": "^26.1.0",
-    "prettier": "^3.5.3",
-    "prettier-plugin-svelte": "^3.4.0",
-    "remark-code-extra": "^1.0.1",
-    "remark-code-frontmatter": "^1.0.0",
-    "resize-observer-polyfill": "^1.5.1",
-    "sass": "^1.89.0",
-    "svelte-check": "^4.2.1",
-    "svelte-eslint-parser": "1.2.0",
-    "svelte-highlight": "^7.8.3",
-    "svg-path-parser": "^1.1.0",
-    "topojson-client": "^3.1.0",
-    "tslib": "^2.8.1",
-    "typedoc": "^0.28.5",
-    "typedoc-plugin-markdown": "^4.6.3",
-    "typescript": "^5.8.3",
-    "vite": "^6.3.5",
-    "vitest": "^3.1.4",
-    "vitest-matchmedia-mock": "^2.0.3"
-  },
-  "types": "./dist/index.d.ts",
-  "type": "module",
-  "dependencies": {
-    "d3-array": "^3.2.4",
-    "d3-color": "^3.1.0",
-    "d3-format": "^3.1.0",
-    "d3-geo": "^3.1.1",
-    "d3-interpolate": "^3.0.1",
-    "d3-path": "^3.1.0",
-    "d3-quadtree": "^3.0.1",
-    "d3-random": "^3.0.1",
-    "d3-regression": "^1.3.10",
-    "d3-scale": "^4.0.2",
-    "d3-scale-chromatic": "^3.1.0",
-    "d3-shape": "^3.2.0",
-    "d3-time": "^3.1.0",
-    "es-toolkit": "^1.38.0",
-    "fast-equals": "^5.2.2",
-    "merge-deep": "^3.0.3",
-    "svelte": "5.33.2"
-  },
-  "scripts": {
-    "dev": "vite dev",
-    "build": "vite build",
-    "preview": "vite preview",
-    "test": "npm run test:unit",
-    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
-    "lint": "prettier --check src && eslint src",
-    "format": "prettier --write .",
-    "test:unit": "vitest",
-    "release-next": "npm version prerelease --preid next && npm publish && git push && git push --tags && sleep 1 && npm dist-tag add svelteplot@$(npm view . version) next",
-    "docs": "npm run build && cd build && rsync --recursive . vis4.net:svelteplot/alpha0/"
-  }
-}
+}