svelteplot 0.10.3-pr-479.0 → 0.10.3-pr-480.0

package/dist/marks/RegressionX.svelte

@@ -4,9 +4,9 @@
 
 <script module lang="ts">
     import type { ChannelAccessor } from '../types/index.js';
-    import type { RegressionMarkProps as BaseRegressionMarkProps } from './helpers/Regression.svelte';
+    import type { RegressionOptions } from './helpers/Regression.svelte';
 
-    export type RegressionXMarkProps = BaseRegressionMarkProps & {
+    export type RegressionXMarkProps = RegressionOptions & {
         data?: Record<string | symbol, any>[];
         z?: ChannelAccessor;
     };

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

@@ -1,6 +1,6 @@
 import type { ChannelAccessor } from '../types/index.js';
-import type { RegressionMarkProps as BaseRegressionMarkProps } from './helpers/Regression.svelte';
-export type RegressionXMarkProps = BaseRegressionMarkProps & {
+import type { RegressionOptions } from './helpers/Regression.svelte';
+export type RegressionXMarkProps = RegressionOptions & {
     data?: Record<string | symbol, any>[];
     z?: ChannelAccessor;
 };

package/dist/marks/RegressionY.svelte

@@ -3,9 +3,9 @@
 -->
 <script module lang="ts">
     import type { ChannelAccessor } from '../types/index.js';
-    import type { RegressionMarkProps as BaseRegressionMarkProps } from './helpers/Regression.svelte';
+    import type { RegressionOptions } from './helpers/Regression.svelte';
 
-    export type RegressionYMarkProps = BaseRegressionMarkProps & {
+    export type RegressionYMarkProps = RegressionOptions & {
         data?: Record<string | symbol, any>[];
         z?: ChannelAccessor;
     };

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

@@ -1,6 +1,6 @@
 import type { ChannelAccessor } from '../types/index.js';
-import type { RegressionMarkProps as BaseRegressionMarkProps } from './helpers/Regression.svelte';
-export type RegressionYMarkProps = BaseRegressionMarkProps & {
+import type { RegressionOptions } from './helpers/Regression.svelte';
+export type RegressionYMarkProps = RegressionOptions & {
     data?: Record<string | symbol, any>[];
     z?: ChannelAccessor;
 };

package/dist/marks/helpers/Regression.svelte

@@ -1,15 +1,15 @@
 <script module lang="ts">
-    import type { BaseMarkProps, ChannelAccessor, FacetContext } from '../../types/index.js';
+    import type { BaseMarkProps, ChannelAccessor } from '../../types/index.js';
 
-    type RegressionType = 'linear' | 'quad' | 'poly' | 'exp' | 'log' | 'pow' | 'loess';
+    export type RegressionType = 'linear' | 'quad' | 'poly' | 'exp' | 'log' | 'pow' | 'loess';
 
-    export type RegressionMarkProps = BaseMarkProps & {
+    export type RegressionOptions = BaseMarkProps & {
         /** the horizontal position channel; bound to the x scale */
         x: ChannelAccessor;
         /** the vertical position channel; bound to the y scale */
         y: ChannelAccessor;
         /** the regression model type */
-        type: RegressionType;
+        type?: RegressionType;
         /**
          * If order is specified, sets the regression's order to the specified number.
          * For example, if order is set to 4, the regression generator will perform a
@@ -19,13 +19,13 @@
          * regression line will fit your data with a high determination coefficient,
          * it may have little predictive power for data outside of your domain.
          */
-        order: number;
+        order?: number;
         /** the base for logarithmic regression */
-        base: number;
+        base?: number;
         /** the bandwidth for LOESS regression, as a fraction of the data range (0 to 1) */
-        span: number;
+        span?: number;
         /** the confidence level for confidence bands (e.g. 0.95 for 95% confidence) */
-        confidence: number;
+        confidence?: number | false;
     };
 </script>
 
@@ -45,25 +45,63 @@
     import { resolveChannel } from '../../helpers/resolve.js';
     import { confidenceInterval } from '../../helpers/math.js';
     import callWithProps from '../../helpers/callWithProps.js';
-    import { isDate } from '../../helpers/typeChecks.js';
-
-    const regressions = new Map<RegressionType, typeof regressionLinear>([
-        ['linear', regressionLinear],
-        ['quad', regressionQuad],
-        ['poly', regressionPoly],
-        ['exp', regressionExp],
-        ['log', regressionLog],
-        ['pow', regressionPow],
-        ['loess', regressionLoess]
-    ]);
-
-    function maybeRegression(name: string) {
-        name = `${name}`.toLowerCase();
-        if (regressions.has(name)) return regressions.get(name);
-        throw new Error('unknown regression ' + name);
+    import type { DataRecord, FacetContext, RawValue } from '../../types/index.js';
+    import { usePlot } from '../../hooks/usePlot.svelte.js';
+
+    type RegressionData = { x: number; y: number };
+    type RegressionOutput = [number, number][] & {
+        predict?: (x: number) => number;
+        predictMany?: (points: number[]) => number[];
+    };
+    type RegressionGenerator = ((data: RegressionData[]) => RegressionOutput) & {
+        x: (fn: (d: RegressionData) => number) => RegressionGenerator;
+        y: (fn: (d: RegressionData) => number) => RegressionGenerator;
+        domain?: (domain: [number, number]) => RegressionGenerator;
+        order?: (order: number) => RegressionGenerator;
+        base?: (base: number) => RegressionGenerator;
+        bandwidth?: (span: number) => RegressionGenerator;
+    };
+    type RegressionFactory = () => RegressionGenerator;
+
+    interface RegressionProps extends RegressionOptions {
+        data: DataRecord[];
+        dependent: 'x' | 'y';
     }
 
-    import { usePlot } from '../../hooks/usePlot.svelte.js';
+    // Normalize all regression constructors behind one callable adapter shape.
+    const regressions: Record<RegressionType, RegressionFactory> = {
+        linear: regressionLinear as RegressionFactory,
+        quad: regressionQuad as RegressionFactory,
+        poly: regressionPoly as RegressionFactory,
+        exp: regressionExp as RegressionFactory,
+        log: regressionLog as RegressionFactory,
+        pow: regressionPow as RegressionFactory,
+        loess: regressionLoess as RegressionFactory
+    };
+
+    function maybeRegression(name: RegressionType): RegressionFactory {
+        const fn = regressions[name];
+        if (fn) return fn;
+        throw new Error(`unknown regression ${name}`);
+    }
+
+    // Regression engines operate on numeric domains; convert Date channels to epoch ms.
+    function toNumeric(value: RawValue): number {
+        return value instanceof Date ? value.valueOf() : Number(value);
+    }
+
+    // Convert generated points back to Date for time scales so downstream marks render correctly.
+    function toOutputX(value: number, scaleType: string): RawValue {
+        return scaleType === 'time' ? new Date(value) : value;
+    }
+
+    function makeTicks(domain: [number, number], count = 40): number[] {
+        const [start, end] = domain;
+        if (start === end) return [start];
+        const tickCount = Math.max(1, count);
+        const step = (end - start) / tickCount;
+        return Array.from({ length: tickCount + 1 }, (_, i) => start + i * step);
+    }
 
     const plot = usePlot();
 
@@ -72,85 +110,129 @@
         dependent,
         type = 'linear',
         order = 3,
-        base = 2.71828,
+        base = Math.E,
         span = 0.3,
         confidence = 0.99,
-        class: className = null,
+        class: className = '',
         ...options
-    }: RegressionMarkProps & { dependent: 'x' | 'y' } = $props();
+    }: RegressionProps = $props();
 
     const { getTestFacet } = getContext<FacetContext>('svelteplot/facet');
-    let testFacet = $derived(getTestFacet());
+    const testFacet = $derived(getTestFacet());
+
+    const filteredData = $derived(data.filter((d) => testFacet(d, options as any)));
 
-    let filteredData = $derived(data.filter((d) => testFacet(d, options)));
+    const independent: 'x' | 'y' = $derived(dependent === 'x' ? 'y' : 'x');
 
-    let independent: 'x' | 'y' = $derived(dependent === 'x' ? 'y' : 'x');
+    const regressionFn = $derived(maybeRegression(type));
 
-    let regressionFn = $derived(maybeRegression(type));
+    // Build a clean numeric input set for regression fitting, dropping invalid rows early.
+    const regressionInput = $derived(
+        filteredData
+            .map((d) => ({
+                x: toNumeric(resolveChannel(independent, d, options as any)),
+                y: toNumeric(resolveChannel(dependent, d, options as any))
+            }))
+            .filter(({ x, y }) => Number.isFinite(x) && Number.isFinite(y))
+    );
 
-    let regression = $derived(
+    const independentDomain = $derived.by(() => {
+        // Prefer the active scale domain, but fall back to observed data when the scale
+        // is still initializing (common in tests and first render passes).
+        const scaleDomain = plot.scales[independent].domain;
+        const scaleStart = toNumeric(scaleDomain[0]);
+        const scaleEnd = toNumeric(scaleDomain.at(-1) ?? scaleDomain[0]);
+        if (Number.isFinite(scaleStart) && Number.isFinite(scaleEnd)) {
+            return scaleStart <= scaleEnd
+                ? ([scaleStart, scaleEnd] as [number, number])
+                : ([scaleEnd, scaleStart] as [number, number]);
+        }
+        if (regressionInput.length === 0) return null;
+        let min = Infinity;
+        let max = -Infinity;
+        for (const point of regressionInput) {
+            if (point.x < min) min = point.x;
+            if (point.x > max) max = point.x;
+        }
+        if (!Number.isFinite(min) || !Number.isFinite(max)) return null;
+        return min <= max ? ([min, max] as [number, number]) : ([max, min] as [number, number]);
+    });
+
+    const regression = $derived(
         callWithProps(regressionFn, [], {
-            x: (d) => resolveChannel(independent, d, options),
-            y: (d) => resolveChannel(dependent, d, options),
+            x: (d: RegressionData) => d.x,
+            y: (d: RegressionData) => d.y,
             ...(type === 'poly' ? { order } : {}),
             ...(type === 'log' ? { base } : {}),
-            ...(!type.startsWith('loess') ? { domain: plot.scales[independent].domain } : {}),
+            ...(type !== 'loess' && independentDomain != null ? { domain: independentDomain } : {}),
             ...(type === 'loess' ? { bandwidth: span } : {})
-        })(filteredData)
+        })(regressionInput)
     );
 
-    let regrPoints = $derived([
-        ...new Set([
-            plot.scales[independent].domain[0],
-            ...plot.scales[independent].fn.ticks(40),
-            plot.scales[independent].domain[1]
-        ])
-    ]);
-
-    let regrData = $derived(
-        regression.predictMany
-            ? regression.predictMany(regrPoints).map((__y, i) => ({ __x: regrPoints[i], __y }))
-            : regression.predict
-              ? regrPoints.map((__x) => {
-                    // const __x = x;
-                    const __y = regression.predict(__x);
-                    return { __x, __y };
-                })
-              : regression.map(([__x, __y]) => ({
-                    __x: plot.scales[independent].type === 'time' ? new Date(__x) : __x,
-                    __y
-                }))
-    );
+    const regrPoints = $derived.by(() => {
+        if (independentDomain == null) return [] as number[];
+        // Use scale ticks when available; otherwise synthesize evenly spaced samples.
+        const ticks = plot.scales[independent].fn
+            .ticks(40)
+            .map(toNumeric)
+            .filter((value): value is number => Number.isFinite(value));
+        const points = ticks.length > 0 ? ticks : makeTicks(independentDomain, 40);
+        return [
+            ...new Set(
+                [independentDomain[0], ...points, independentDomain[1]].filter(
+                    (value): value is number => Number.isFinite(value)
+                )
+            )
+        ].sort((a, b) => a - b);
+    });
 
-    let stroke = $derived(
-        options.stroke != null ? resolveChannel('stroke', filteredData[0], options) : null
-    );
+    const regrData = $derived.by(() => {
+        // Prefer batch prediction when supported, then per-point predict, then raw curve output.
+        if (typeof regression.predictMany === 'function') {
+            return regression.predictMany(regrPoints).map((__y, i) => ({
+                __x: toOutputX(regrPoints[i], plot.scales[independent].type),
+                __y
+            }));
+        }
+        if (typeof regression.predict === 'function') {
+            return regrPoints.map((point) => ({
+                __x: toOutputX(point, plot.scales[independent].type),
+                __y: regression.predict!(point)
+            }));
+        }
+        return regression.map(([__x, __y]) => ({
+            __x: toOutputX(__x, plot.scales[independent].type),
+            __y
+        }));
+    });
 
-    let confBandGen = $derived(
-        confidence !== false && regression.predict
-            ? confidenceInterval(
-                  data
-                      .map((d) => ({
-                          x: resolveChannel(independent, d, options),
-                          y: resolveChannel(dependent, d, options)
-                      }))
-                      .filter(
-                          ({ x, y }) => (Number.isFinite(x) || isDate(x)) && Number.isFinite(y)
-                      ),
-                  regression.predict,
-                  1 - confidence
-              )
+    const stroke = $derived(
+        options.stroke != null && filteredData.length
+            ? resolveChannel('stroke', filteredData[0], options as any)
             : null
     );
 
-    let confBandData = $derived(
-        confidence !== false && regression.predict
-            ? regrPoints.map((x) => {
-                  const { x: __x, left, right } = confBandGen(x);
-                  return { __x, __y1: left, __y2: right };
-              })
-            : []
+    const confBandGen = $derived(
+        // Confidence bands require a predictor function and at least 3 points.
+        confidence !== false &&
+            typeof confidence === 'number' &&
+            typeof regression.predict === 'function' &&
+            regressionInput.length > 2
+            ? confidenceInterval(regressionInput, regression.predict, 1 - confidence)
+            : null
     );
+
+    const confBandData = $derived.by(() => {
+        if (confBandGen == null) return [];
+        return regrPoints.map((x) => {
+            const { x: __x, left, right } = confBandGen(x);
+            return {
+                __x: toOutputX(__x, plot.scales[independent].type),
+                __y1: left,
+                __y2: right
+            };
+        });
+    });
 </script>
 
 {#if filteredData.length}

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

@@ -1,12 +1,12 @@
 import type { BaseMarkProps, ChannelAccessor } from '../../types/index.js';
-type RegressionType = 'linear' | 'quad' | 'poly' | 'exp' | 'log' | 'pow' | 'loess';
-export type RegressionMarkProps = BaseMarkProps & {
+export type RegressionType = 'linear' | 'quad' | 'poly' | 'exp' | 'log' | 'pow' | 'loess';
+export type RegressionOptions = BaseMarkProps & {
     /** the horizontal position channel; bound to the x scale */
     x: ChannelAccessor;
     /** the vertical position channel; bound to the y scale */
     y: ChannelAccessor;
     /** the regression model type */
-    type: RegressionType;
+    type?: RegressionType;
     /**
      * If order is specified, sets the regression's order to the specified number.
      * For example, if order is set to 4, the regression generator will perform a
@@ -16,17 +16,19 @@ export type RegressionMarkProps = BaseMarkProps & {
      * regression line will fit your data with a high determination coefficient,
      * it may have little predictive power for data outside of your domain.
      */
-    order: number;
+    order?: number;
     /** the base for logarithmic regression */
-    base: number;
+    base?: number;
     /** the bandwidth for LOESS regression, as a fraction of the data range (0 to 1) */
-    span: number;
+    span?: number;
     /** the confidence level for confidence bands (e.g. 0.95 for 95% confidence) */
-    confidence: number;
+    confidence?: number | false;
 };
-type $$ComponentProps = RegressionMarkProps & {
+import type { DataRecord } from '../../types/index.js';
+interface RegressionProps extends RegressionOptions {
+    data: DataRecord[];
     dependent: 'x' | 'y';
-};
-declare const Regression: import("svelte").Component<$$ComponentProps, {}, "">;
+}
+declare const Regression: import("svelte").Component<RegressionProps, {}, "">;
 type Regression = ReturnType<typeof Regression>;
 export default Regression;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "svelteplot",
-    "version": "0.10.3-pr-479.0",
+    "version": "0.10.3-pr-480.0",
     "description": "A Svelte-native data visualization framework based on the layered grammar of graphics principles.",
     "keywords": [
         "svelte",