svelteplot 0.10.3 → 0.11.0

package/dist/core/Plot.svelte

@@ -14,6 +14,7 @@
 
     import type {
         PlotOptions,
+        ResolvedPlotOptions,
         GenericMarkOptions,
         Mark,
         PlotScales,
@@ -59,6 +60,11 @@
 
     // default settings in the plot and marks can be overwritten by
     // defining the svelteplot/defaults context outside of Plot
+    const asGridDefaults = (opts: PlotDefaults['grid'] | undefined) =>
+        opts === true ? { implicit: true } : opts == null ? {} : opts;
+    const isImplicit = (opts: { implicit?: boolean } | true | undefined) =>
+        opts === true ? true : (opts?.implicit ?? false);
+
     const DEFAULTS: PlotDefaults = {
         height: 350,
         initialWidth: 500,
@@ -88,20 +94,20 @@
         axisY: {
             anchor: 'left',
             implicit: true,
-            ...USER_DEFAULTS.axis,
-            ...USER_DEFAULTS.axisY
+            ...(USER_DEFAULTS.axis as any),
+            ...(USER_DEFAULTS.axisY as any)
         },
         gridX: {
             implicit: false,
-            ...USER_DEFAULTS.grid,
-            ...USER_DEFAULTS.gridX
+            ...asGridDefaults(USER_DEFAULTS.grid),
+            ...asGridDefaults(USER_DEFAULTS.gridX)
         },
         gridY: {
             implicit: false,
-            ...USER_DEFAULTS.grid,
-            ...USER_DEFAULTS.gridY
+            ...asGridDefaults(USER_DEFAULTS.grid),
+            ...asGridDefaults(USER_DEFAULTS.gridY)
         }
-    };
+    } as PlotDefaults;
 
     let {
         header,
@@ -165,7 +171,7 @@
     );
 
     const explicitDomains = $derived(
-        new Set(SCALES.filter((scale) => !!initialOptions[scale]?.domain))
+        new Set(SCALES.filter((scale) => !!(initialOptions as any)[scale]?.domain))
     );
 
     // one-dimensional plots have different automatic margins and heights
@@ -178,7 +184,7 @@
             explicitScales,
             explicitDomains,
             hasProjection: !!initialOptions.projection,
-            margin: initialOptions.margin,
+            margin: initialOptions.margin as number | 'auto' | undefined,
             inset: initialOptions.inset
         })
     );
@@ -211,7 +217,7 @@
 
     const defaultPointScaleHeight = $derived(
         explicitScales.has('r') && plotOptions.r.range
-            ? plotOptions.r.range[1] * 2
+            ? (plotOptions.r.range[1] as number) * 2
             : DEFAULTS.pointScaleHeight
     );
 
@@ -227,8 +233,8 @@
             ? plotOptions.height(plotWidth)
             : maybeNumber(plotOptions.height) === null || plotOptions.height === 'auto'
               ? Math.round(
-                    preScales.projection && preScales.projection.aspectRatio
-                        ? ((plotWidth * preScales.projection.aspectRatio) / xFacetCount) *
+                    preScales.projection && (preScales.projection as any).aspectRatio
+                        ? ((plotWidth * (preScales.projection as any).aspectRatio) / xFacetCount) *
                               yFacetCount +
                               plotOptions.marginTop +
                               plotOptions.marginBottom
@@ -254,7 +260,7 @@
               : maybeNumber(plotOptions.height)
     );
 
-    const plotHeight = $derived(height - plotOptions.marginTop - plotOptions.marginBottom);
+    const plotHeight = $derived((height ?? 0) - plotOptions.marginTop - plotOptions.marginBottom);
 
     // TODO: check if there's still a reason to store and expose the plot body element
     let plotBody: HTMLDivElement | null = $state(null);
@@ -274,7 +280,7 @@
         const scales = computeScales(
             plotOptions,
             facetWidth || width,
-            facetHeight || height,
+            facetHeight ?? height ?? 0,
             hasFilledDotMarks,
             marks,
             DEFAULTS
@@ -287,9 +293,9 @@
         return {
             options: plotOptions,
             width,
-            height,
-            facetWidth,
-            facetHeight,
+            height: height ?? 0,
+            facetWidth: facetWidth ?? undefined,
+            facetHeight: facetHeight ?? undefined,
             plotHeight,
             plotWidth,
             scales,
@@ -297,7 +303,7 @@
             hasFilledDotMarks,
             body: plotBody,
             css
-        };
+        } as any;
     }
 
     setContext('svelteplot', {
@@ -357,11 +363,11 @@
         const xDomainExtent =
             x.type === 'band' || x.type === 'point'
                 ? x.domain.length
-                : Math.abs(x.domain[1] - x.domain[0]);
+                : Math.abs((x.domain[1] as number) - (x.domain[0] as number));
         const yDomainExtent =
             y.type === 'band' || y.type === 'point'
                 ? y.domain.length
-                : Math.abs(y.domain[1] - y.domain[0]);
+                : Math.abs((y.domain[1] as number) - (y.domain[0] as number));
         return (
             ((plotWidth / xDomainExtent) * yDomainExtent) / aspectRatio + marginTop + marginBottom
         );
@@ -370,13 +376,13 @@
     function extendPlotOptions(
         initialOpts: Partial<PlotOptions>,
         opts: PlotOptionsParameters
-    ): PlotOptions {
+    ): ResolvedPlotOptions {
         return mergeDeep<PlotOptions>(
-            {},
-            { sortOrdinalDomains: DEFAULTS.sortOrdinalDomains },
-            smartDefaultPlotOptions(opts),
-            initialOptions
-        );
+            {} as Partial<PlotOptions>,
+            { sortOrdinalDomains: DEFAULTS.sortOrdinalDomains } as Partial<PlotOptions>,
+            smartDefaultPlotOptions(opts) as any,
+            initialOptions as any
+        ) as ResolvedPlotOptions;
     }
 
     function maybeMargin(
@@ -419,7 +425,7 @@
         explicitDomains,
         hasProjection,
         margin
-    }: PlotOptionsParameters): PlotOptions {
+    }: PlotOptionsParameters): ResolvedPlotOptions {
         const autoXAxis = explicitScales.has('x') || explicitDomains.has('x');
         const autoYAxis = explicitScales.has('y') || explicitDomains.has('y');
         const isOneDimensional = autoXAxis !== autoYAxis;
@@ -444,9 +450,9 @@
             marginTop: maybeMargin(margin, 'top', DEFAULTS.margin, autoMargins),
             marginBottom: maybeMargin(margin, 'bottom', DEFAULTS.margin, autoMargins),
             inset: isOneDimensional ? 10 : DEFAULTS.inset,
-            grid: (DEFAULTS.gridX?.implicit ?? false) && (DEFAULTS.gridY?.implicit ?? false),
+            grid: isImplicit(DEFAULTS.gridX) && isImplicit(DEFAULTS.gridY),
             axes: (DEFAULTS.axisX?.implicit ?? false) && (DEFAULTS.axisY?.implicit ?? false),
-            frame: DEFAULTS.frame?.implicit ?? false,
+            frame: isImplicit(DEFAULTS.frame),
             projection: null,
             aspectRatio: null,
             facet: {},
@@ -464,7 +470,7 @@
                 align: 0.5,
                 tickSpacing: DEFAULTS.axisX.tickSpacing ?? 80,
                 tickFormat: 'auto',
-                grid: DEFAULTS.gridX.implicit ?? false
+                grid: isImplicit(DEFAULTS.gridX)
             },
             y: {
                 type: 'auto',
@@ -479,7 +485,7 @@
                 align: 0.5,
                 tickSpacing: DEFAULTS.axisY.tickSpacing ?? 50,
                 tickFormat: 'auto',
-                grid: DEFAULTS.gridY.implicit ?? false
+                grid: isImplicit(DEFAULTS.gridY)
             },
             opacity: {
                 type: 'linear',
@@ -504,14 +510,14 @@
                 padding: 0,
                 align: 0
             },
-            color: { type: 'auto', unknown: DEFAULTS.unknown },
+            color: { type: 'auto' as any, unknown: DEFAULTS.unknown },
             length: { type: 'linear' },
             symbol: { type: 'ordinal' },
             fx: { type: 'band', axis: 'top' },
             fy: { type: 'band', axis: 'right' },
             locale: DEFAULTS.locale,
             css: DEFAULTS.css
-        };
+        } as ResolvedPlotOptions;
     }
 
     const mapXY = $derived((x: RawValue, y: RawValue) => {
@@ -542,7 +548,7 @@
                 {#if children}
                     {@render children({
                         width,
-                        height,
+                        height: height ?? 0,
                         options: plotOptions,
                         scales: plotState.scales,
                         mapXY,
@@ -558,7 +564,7 @@
         {#if overlay}<div class="plot-overlay">
                 {@render overlay?.({
                     width,
-                    height,
+                    height: height ?? 0,
                     options: plotOptions,
                     scales: plotState.scales,
                     mapXY,

package/dist/helpers/autoScales.d.ts

@@ -1,5 +1,5 @@
 import type { ColorScaleOptions, PlotDefaults, PlotOptions, RawValue, ScaleName, ScaleOptions, ScaleType } from '../types/index.js';
-export declare function autoScale({ name, type, domain, scaleOptions, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults }: {
+export declare function autoScale({ name, type, domain, scaleOptions, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults: _plotDefaults }: {
     name: ScaleName;
     type: ScaleType;
     domain: RawValue[];
@@ -9,8 +9,8 @@ export declare function autoScale({ name, type, domain, scaleOptions, plotOption
     plotHeight: number;
     plotHasFilledDotMarks: boolean;
     plotDefaults: PlotDefaults;
-}): (val: any) => any;
-export declare function autoScaleColor({ type, domain, scaleOptions, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults }: {
+}): any;
+export declare function autoScaleColor({ type, domain, scaleOptions, plotOptions: _plotOptions, plotWidth: _plotWidth, plotHeight: _plotHeight, plotHasFilledDotMarks: _plotHasFilledDotMarks, plotDefaults }: {
     name: ScaleName;
     type: ScaleType;
     domain: RawValue[];

package/dist/helpers/autoScales.js

@@ -41,7 +41,7 @@ const ThresholdScales = {
     quantize: scaleQuantize,
     quantile: scaleQuantile
 };
-export function autoScale({ name, type, domain, scaleOptions, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults }) {
+export function autoScale({ name, type, domain, scaleOptions, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults: _plotDefaults }) {
     let fn;
     let range;
     range =
@@ -55,7 +55,7 @@ export function autoScale({ name, type, domain, scaleOptions, plotOptions, plotW
     const scaleProps = {
         domain,
         range,
-        ...((type === 'linear' || type === 'log') && scaleOptions.nice
+        ...((type === 'linear' || type === 'log' || type === 'time') && scaleOptions.nice
             ? {
                 nice: scaleOptions.nice ? niceTickCount : true
             }
@@ -92,6 +92,8 @@ export function autoScale({ name, type, domain, scaleOptions, plotOptions, plotW
             }
             : {})
     };
+    // The scale function is augmented with custom ticks() methods below,
+    // so we type it broadly to allow property assignments
     fn = callWithProps(Scales[type], [], scaleProps);
     if (type === 'band' || type === 'point') {
         fn.ticks = () => domain;
@@ -102,13 +104,13 @@ export function autoScale({ name, type, domain, scaleOptions, plotOptions, plotW
     else if (type === 'symlog') {
         const maxabs = Math.max(Math.abs(domain[0]), Math.abs(domain[1]));
         fn.ticks = (count) => {
-            const ticks = getLogTicks([scaleProps.constant + 1, maxabs], count / 2);
+            const ticks = getLogTicks([(scaleProps.constant ?? 1) + 1, maxabs], count / 2);
             return [...ticks.map((t) => -t).reverse(), 0, ...ticks];
         };
     }
     return fn;
 }
-export function autoScaleColor({ type, domain, scaleOptions, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults }) {
+export function autoScaleColor({ type, domain, scaleOptions, plotOptions: _plotOptions, plotWidth: _plotWidth, plotHeight: _plotHeight, plotHasFilledDotMarks: _plotHasFilledDotMarks, plotDefaults }) {
     let fn;
     let range;
     // special treatment for color scales
@@ -117,12 +119,14 @@ export function autoScaleColor({ type, domain, scaleOptions, plotOptions, plotWi
         // categorical
         let scheme_ = scheme || plotDefaults.categoricalColorScheme;
         if (isPlainObject(scheme_)) {
-            const newScheme = Object.values(scheme_);
-            const newDomain = Object.keys(scheme_);
+            const schemeObj = scheme_;
+            const newScheme = Object.values(schemeObj);
+            const newDomain = Object.keys(schemeObj);
             // for every value in domain that's not part of the scheme, map to unknown
             for (const v of domain) {
-                if (scheme_[v] == null) {
-                    newDomain.push(v);
+                const key = String(v);
+                if (schemeObj[key] == null) {
+                    newDomain.push(key);
                     newScheme.push(unknown);
                 }
             }
@@ -133,11 +137,13 @@ export function autoScaleColor({ type, domain, scaleOptions, plotOptions, plotWi
         range = Array.isArray(scheme_)
             ? scheme_
             : isCategoricalScheme(scheme_)
-                ? categoricalSchemes.get(scheme_)
+                ? (categoricalSchemes.get(scheme_) ?? [])
                 : ordinalScheme(scheme_)(domain.length);
-        fn = scaleOrdinal().domain(domain).range(range);
+        fn = scaleOrdinal()
+            .domain(domain)
+            .range(range);
     }
-    else if (!!ThresholdScales[type]) {
+    else if (ThresholdScales[type]) {
         const scheme_ = scheme || plotDefaults.colorScheme;
         range =
             Array.isArray(scheme_) && (scaleOptions.n == null || scaleOptions.n === scheme_.length)
@@ -146,7 +152,7 @@ export function autoScaleColor({ type, domain, scaleOptions, plotOptions, plotWi
                     ? // interpolate n colors from custom colors
                         d3Range(n)
                             .map((i) => i / (n - 1))
-                            .map(scaleLinear(scheme_.map((c, i) => i / (scheme_.length - 1)), scheme_).interpolate(interpolateLab))
+                            .map(scaleLinear(scheme_.map((_c, i) => i / (scheme_.length - 1)), scheme_).interpolate(interpolateLab))
                     : interpolate
                         ? d3Range(n).map((i) => interpolate(i / (n - 1)))
                         : isOrdinalScheme(scheme_)
@@ -157,11 +163,15 @@ export function autoScaleColor({ type, domain, scaleOptions, plotOptions, plotWi
         }
         if (scaleOptions.reverse)
             range = range.toReversed();
-        fn = ThresholdScales[type]().domain(domain).range(range);
+        fn = ThresholdScales[type]()
+            .domain(domain)
+            .range(range);
     }
-    else if (!!SequentialScales[type] || !!DivergingScales[type]) {
+    else if (SequentialScales[type] ||
+        DivergingScales[type]) {
         // continuous color scale
-        const scale = SequentialScales[type] || DivergingScales[type];
+        const scale = (SequentialScales[type] ||
+            DivergingScales[type]);
         const scheme_ = scheme || plotDefaults.colorScheme;
         if (interpolate) {
             // user-defined interpolation function [0, 1] -> color
@@ -172,14 +182,14 @@ export function autoScaleColor({ type, domain, scaleOptions, plotOptions, plotWi
             const step = 1 / (scheme_.length - 1);
             fn = scale(domain, (type === 'linear' ? scaleLinear : scaleLog)(d3Range(0, 1 + step / 2, step), scheme_).interpolate(interpolateLab));
         }
-        else if (!!DivergingScales[type] ||
+        else if (DivergingScales[type] ||
             (scaleOptions.type === 'auto' && isDivergingScheme(scheme_))) {
             // diverging color scheme, explicit or auto-detected
             const maxabs = Math.max(Math.abs(domain[0]), Math.abs(domain[1]));
             const domain_ = pivot != null ? [domain[0], pivot, domain[1]] : [-maxabs, 0, maxabs];
             fn = scale(domain_, quantitativeScheme(scheme_));
         }
-        else if (!!SequentialScales[type] ||
+        else if (SequentialScales[type] ||
             (scaleOptions.type === 'auto' && isQuantitativeScheme(scheme_))) {
             // sequential
             fn = scale(domain, quantitativeScheme(scheme_));
@@ -191,7 +201,7 @@ export function autoScaleColor({ type, domain, scaleOptions, plotOptions, plotWi
     if (!fn) {
         console.error('color problem', type);
         // problem
-        fn = () => 'red';
+        fn = (() => 'red');
         fn.range = () => ['red'];
     }
     return fn;

package/dist/helpers/autoTicks.js

@@ -37,6 +37,8 @@ export function autoTicks(type, ticks, interval, domain, scaleFn, count) {
         if (lo == null || hi == null)
             return [];
         const I = maybeInterval(interval);
+        if (!I)
+            return [];
         return I.range(lo, I.offset(hi)).filter((d) => d >= lo && d <= hi);
     }
     return typeof scaleFn.ticks === 'function' ? scaleFn.ticks(count) : [];

package/dist/helpers/callWithProps.d.ts

@@ -1,6 +1,5 @@
-import type { RawValue } from '../types/index.js';
 /**
  * Helper function to call a D3 "function class" while also calling
  * property setter functions on the result.
  */
-export default function <T extends object>(d3func: (...args: RawValue[]) => T, args?: RawValue[], props?: Record<string, RawValue>): T;
+export default function <T extends object>(d3func: (...args: any[]) => T, args?: any[], props?: Record<string, any>): T;

package/dist/helpers/facets.js

@@ -46,4 +46,3 @@ export function getEmptyFacets(marks, fxValues, fyValues) {
     }
     return out;
 }
-// TODO: write unit tests

package/dist/helpers/index.js

@@ -12,7 +12,7 @@ export function coalesce(...args) {
     return null; // Return null if all arguments are null or undefined
 }
 export function testFilter(datum, options) {
-    return options.filter == null || resolveProp(options.filter, datum);
+    return (options.filter == null || resolveProp(options.filter, datum));
 }
 export function randomId() {
     return Math.ceil(1e9 + Math.random() * 1e9).toString(36);

package/dist/helpers/mergeDeep.d.ts

@@ -1,5 +1,3 @@
-type ObjectType = {
-    [key: string]: any;
-};
+type ObjectType = Record<string, unknown>;
 export default function mergeDeep<T extends ObjectType>(target: Partial<T>, ...sources: Partial<T>[]): T;
 export {};

package/dist/helpers/mergeDeep.js

@@ -1,25 +1,24 @@
 function isObject(item) {
-    return item && typeof item === 'object' && !Array.isArray(item);
+    return item != null && typeof item === 'object' && !Array.isArray(item);
 }
 export default function mergeDeep(target, ...sources) {
-    if (!sources.length)
-        return target;
-    const source = sources.shift();
-    if (isObject(target) && isObject(source)) {
-        for (const key in source) {
-            if (isObject(source[key])) {
-                if (!target[key]) {
-                    Object.assign(target, { [key]: {} });
+    for (const source of sources) {
+        if (isObject(target) && isObject(source)) {
+            for (const key in source) {
+                if (isObject(source[key])) {
+                    if (!target[key]) {
+                        Object.assign(target, { [key]: {} });
+                    }
+                    else {
+                        target[key] = Object.assign({}, target[key]);
+                    }
+                    mergeDeep(target[key], source[key]);
                 }
-                else {
-                    target[key] = Object.assign({}, target[key]);
+                else if (source[key] !== null) {
+                    Object.assign(target, { [key]: source[key] });
                 }
-                mergeDeep(target[key], source[key]);
-            }
-            else if (source[key] !== null) {
-                Object.assign(target, { [key]: source[key] });
             }
         }
     }
-    return mergeDeep(target, ...sources);
+    return target;
 }

package/dist/helpers/projection.d.ts

@@ -1,3 +1,4 @@
+import { type GeoStream } from 'd3-geo';
 export type Clip = boolean | null | number | 'frame';
 type ProjectionOptions = {
     type: string;
@@ -25,9 +26,9 @@ export declare function createProjection({ projOptions, inset: globalInset, inse
     insetRight?: number;
     insetBottom?: number;
     insetLeft?: number;
-} | undefined, dimensions: Dimensions): string | ProjectionOptions | {
+} | undefined, dimensions: Dimensions): ProjectionOptions | {
     aspectRatio: number;
-    invert([x, y]: [any, any]): any;
-    stream: (s: any) => any;
+    invert([x, y]: [number, number]): any;
+    stream: (s: GeoStream) => any;
 } | undefined;
 export {};

package/dist/helpers/projection.js

@@ -7,7 +7,7 @@ export function createProjection({ projOptions, inset: globalInset = 2, insetTop
     if (projOptions == null)
         return;
     // projection function passed as projection option
-    if (typeof projOptions.stream === 'function')
+    if (typeof projOptions !== 'string' && typeof projOptions.stream === 'function')
         return projOptions; // d3 projection
     let options;
     let domain;
@@ -34,7 +34,16 @@ export function createProjection({ projOptions, inset: globalInset = 2, insetTop
     }
     // let projFactory;
     let aspectRatio = defaultAspectRatio;
-    const projFactory = projOptions;
+    let projFactory;
+    if (typeof projOptions === 'function') {
+        // After destructuring, projOptions may be reassigned from an object `type` property,
+        // which can be a projection initializer function.
+        projFactory = projOptions;
+    }
+    else if (typeof projOptions === 'string') {
+        // String projection types are not handled here; treat as no projection.
+        return;
+    }
     // Compute the frame dimensions and invoke the projection initializer.
     const { width, height, marginLeft, marginRight, marginTop, marginBottom } = dimensions;
     const dx = width - marginLeft - marginRight - insetLeft - insetRight;
@@ -43,7 +52,7 @@ export function createProjection({ projOptions, inset: globalInset = 2, insetTop
     // The projection initializer might decide to not use a projection.
     if (projInstance == null)
         return;
-    clip = maybePostClip(clip, marginLeft, marginTop, width - marginRight, height - marginBottom);
+    const postClip = maybePostClip(clip, marginLeft, marginTop, width - marginRight, height - marginBottom);
     // Translate the origin to the top-left corner, respecting margins and insets.
     let tx = marginLeft + insetLeft;
     let ty = marginTop + insetTop;
@@ -63,7 +72,10 @@ export function createProjection({ projOptions, inset: globalInset = 2, insetTop
                     this.stream.point(x * k + tx, y * k + ty);
                 }
             });
-            invertTransform = ([x, y]) => [(x - tx) / k, (y - ty) / k];
+            invertTransform = ([x, y]) => [
+                (x - tx) / k,
+                (y - ty) / k
+            ];
         }
         else {
             // eslint-disable-next-line no-console
@@ -88,7 +100,7 @@ export function createProjection({ projOptions, inset: globalInset = 2, insetTop
         invert([x, y]) {
             return projInstance.invert(invertTransform([x, y]));
         },
-        stream: (s) => projInstance.stream(transform.stream(clip(s)))
+        stream: (s) => projInstance.stream(transform.stream(postClip(s)))
     };
 }
 function maybePostClip(clip, x1, y1, x2, y2) {

package/dist/helpers/reduce.d.ts

@@ -1,10 +1,10 @@
-import type { ChannelName, Channels, DataRecord, DataRow, RawValue } from '../types/index.js';
-type ReducerFunc = (group: Iterable<DataRow>) => RawValue;
+import type { ChannelName, Channels, DataRecord } from '../types/index.js';
+type ReducerFunc = (group: Iterable<any>, ...rest: any[]) => any;
 type ReducerOption = ReducerName | ReducerFunc;
 type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
 export type ReducerPercentile = (`p${Digit}${Digit}` & Record<never, never>) | 'p25' | 'p50' | 'p75';
 export type ReducerName = 'count' | 'deviation' | 'difference' | 'first' | 'last' | 'max' | 'mean' | 'median' | 'min' | 'mode' | 'ratio' | 'sum' | 'variance' | ReducerPercentile;
-export declare const Reducer: Record<ReducerName, ReducerFunc>;
+export declare const Reducer: Record<string, ReducerFunc>;
 export declare function mayberReducer(r: ReducerOption): ReducerFunc;
-export declare function reduceOutputs(newDatum: DataRecord, data: DataRecord[], options: Record<ChannelName, ReducerOption>, outputs: Iterable<ChannelName>, channels: Channels, newChannels: Channels): void;
+export declare function reduceOutputs(newDatum: DataRecord, data: DataRecord[], options: Record<ChannelName, ReducerOption>, outputs: Iterable<ChannelName>, channels: Channels<any>, newChannels: Channels<any>): void;
 export {};

package/dist/helpers/reduce.js

@@ -7,6 +7,8 @@ const niceReduceNames = {
     deviation: 'Standard Deviation',
     mean: 'Average'
 };
+// Typed as Record<string, ...> because the Proxy wrapper adds virtual
+// percentile keys (p00–p99) that don't exist on the static object
 const StaticReducer = {
     count: (d) => Array.from(d).length,
     min,
@@ -18,10 +20,10 @@ const StaticReducer = {
     identity: (d) => d,
     variance,
     deviation,
-    first: (d) => d[0],
-    last: (d) => d.at(-1),
-    difference: (d) => d.at(-1) - d[0],
-    ratio: (d) => d.at(-1) / d[0]
+    first: ((d) => d[0]),
+    last: ((d) => d.at(-1)),
+    difference: ((d) => d.at(-1) - d[0]),
+    ratio: ((d) => d.at(-1) / d[0])
     // TODO: proportion
     // TODO: proportion-facet
     // TODO: min-index

package/dist/helpers/regressionLoess.js

@@ -1,6 +1,7 @@
+// @ts-expect-error loess has no type declarations
 import Loess from 'loess';
 function toNumber(d) {
-    if (typeof d.getTime === 'function')
+    if (d instanceof Date)
         return d.getTime();
     return d;
 }

package/dist/helpers/resolve.d.ts

@@ -11,11 +11,14 @@ type ChannelOptions = {
 };
 export declare function toChannelOption(name: ScaledChannelName, channel: ChannelAccessor | ChannelAlias): ChannelOptions;
 export declare function resolveChannel<T>(channel: ChannelName, datum: DataRow<T>, channels: Partial<Record<ChannelName, ChannelAccessor<T> | ChannelAlias>>): RawValue;
-export declare function resolveScaledStyleProps(datum: DataRecord, channels: Partial<Record<ScaledChannelName, ChannelAccessor>>, useScale: Record<ScaledChannelName, boolean>, plot: PlotState, defaultColorProp?: 'fill' | 'stroke' | null): any;
-export declare function resolveScaledStyles(datum: DataRecord, channels: Partial<Record<ScaledChannelName, ChannelAccessor> & {
+export declare function resolveScaledStyleProps(datum: DataRecord, channels: Partial<Record<ScaledChannelName | MarkStyleProps, ChannelAccessor>>, useScale: Record<ScaledChannelName, boolean>, plot: PlotState, defaultColorProp?: 'fill' | 'stroke' | null): {
+    fill: string;
+    stroke: string;
+};
+export declare function resolveScaledStyles(datum: DataRecord, channels: Partial<Record<ScaledChannelName | MarkStyleProps, ChannelAccessor> & {
     style: string;
 }>, useScale: Record<ScaledChannelName, boolean>, plot: PlotState, defaultColorProp?: 'fill' | 'stroke' | null): string;
-export declare function resolveStyles(plot: PlotState, datum: ScaledDataRecord, channels: Partial<Record<ChannelName & MarkStyleProps, ChannelAccessor> & {
+export declare function resolveStyles(plot: PlotState, datum: ScaledDataRecord, channels: Partial<Record<ScaledChannelName | MarkStyleProps, ChannelAccessor> & {
     style: string;
 }>, defaultColorProp: "fill" | "stroke" | null | undefined, useScale: Record<ScaledChannelName, boolean>, recomputeChannels?: boolean): [string | null, string | null];
 export {};