svelteplot 0.10.3 → 0.11.0-pr-514.0

package/dist/transforms/stack.js

@@ -2,7 +2,7 @@ import isDataRecord from '../helpers/isDataRecord.js';
 import { resolveChannel, resolveProp } from '../helpers/resolve.js';
 import { stack, stackOffsetExpand, stackOffsetSilhouette, stackOffsetWiggle, stackOrderAppearance, stackOrderAscending, stackOrderInsideOut, stackOrderNone, stackOffsetDiverging } from 'd3-shape';
 import { sum, groups as d3Groups, min, range } from 'd3-array';
-import { groupFacetsAndZ } from '../helpers/group';
+import { groupFacetsAndZ } from '../helpers/group.js';
 import { filter } from './filter.js';
 import { sort } from './sort.js';
 import { INDEX, ORIGINAL_NAME_KEYS } from '../constants.js';
@@ -55,7 +55,7 @@ function stackXY(byDim, data, channels, options) {
         channels[`${byLow}`] === undefined &&
         channels[`${byHigh}`] === undefined) {
         // resolve all channels for easier computation below
-        const resolvedData = indexData(data).map((d, i) => ({
+        const resolvedData = indexData(data).map((d) => ({
             ...(isDataRecord(d) ? d : { [RAW_VALUE]: d }),
             [S[secondDim]]: resolveChannel(secondDim, d, channels),
             [GROUP]: groupBy === true ? 'G' : resolveChannel(groupBy, d, channels),
@@ -91,7 +91,7 @@ function stackXY(byDim, data, channels, options) {
                 // Unit stacking: map each secondary-dimension bucket to an array of values.
                 // Series are positional (0..N-1) within each bucket.
                 let maxKeys = 0;
-                stackData = groupedBySecondDim.map(([k, items]) => {
+                stackData = groupedBySecondDim.map(([_k, items]) => {
                     const values = items
                         // keep original order within bucket; no stable series identity across buckets
                         .map((d) => ({ i: d[INDEX], v: d[S[byDim]] }));
@@ -104,7 +104,7 @@ function stackXY(byDim, data, channels, options) {
             else {
                 // Grouped stacking: keep consistent series identities using the group key
                 const keySet = new Set(facetData.map((d) => d[GROUP]));
-                stackData = groupedBySecondDim.map(([k, items]) => {
+                stackData = groupedBySecondDim.map(([_k, items]) => {
                     const obj = {};
                     items.forEach((d) => {
                         const key = d[GROUP];
@@ -130,11 +130,11 @@ function stackXY(byDim, data, channels, options) {
             const series = stack()
                 .order(stackOrder)
                 // Wiggle requires consistent series identities; fall back to 'center' for unit stacking
-                .offset(groupBy === true && options.offset === 'wiggle'
+                .offset((groupBy === true && options.offset === 'wiggle'
                 ? STACK_OFFSET['center']
-                : STACK_OFFSET[options.offset])
+                : STACK_OFFSET[options.offset ?? 'none']))
                 .keys(keys)
-                .value((d, key, i, data) => {
+                .value((d, key, _i, _data) => {
                 return d[key]?.v == null ? undefined : d[key]?.v;
             })(stackData);
             // and combine it all back into a flat array
@@ -153,21 +153,28 @@ function stackXY(byDim, data, channels, options) {
             ...(typeof channels[byDim] === 'string' && !channels[ORIGINAL_NAME_KEYS[byDim]]
                 ? { [ORIGINAL_NAME_KEYS[byDim]]: channels[byDim] }
                 : {}),
-            ...{ [byLow]: S[byLow], [byHigh]: S[byHigh] }
+            [byLow]: S[byLow],
+            [byHigh]: S[byHigh]
         };
     }
     return { data, ...channels };
 }
+/**
+ * stacks data along the y dimension, producing y1 and y2 channels
+ */
 export function stackY({ data, ...channels }, opts = {}) {
     return stackXY('y', data, channels, applyDefaults(opts));
 }
+/**
+ * stacks data along the x dimension, producing x1 and x2 channels
+ */
 export function stackX({ data, ...channels }, opts = {}) {
     return stackXY('x', data, channels, applyDefaults(opts));
 }
 function applyDefaults(opts) {
     if (opts === false)
         return false;
-    if (opts.offset === 'wiggle' && opts.order === undefined) {
+    if (typeof opts === 'object' && opts.offset === 'wiggle' && opts.order === undefined) {
         return { ...DEFAULT_STACK_OPTIONS, order: 'inside-out', ...opts };
     }
     return { ...DEFAULT_STACK_OPTIONS, ...opts };
@@ -198,13 +205,14 @@ function stackMosaic({ data, x, y, value, fx, fy, ...rest }, { outer, inner }, {
         const innerOpt = inner === 'x' ? xOpt : yOpt;
         const grouped = d3Groups(data, (d) => resolveProp(d[outerChannel], d));
         const innerOrder = new Map(grouped[0][1].map((d, i) => [d[innerChannel], i]));
-        grouped.forEach(([k, items], i) => {
+        grouped.forEach(([_k, items], i) => {
             const groupValue = sum(items, (d) => resolveProp(d[value], d));
             const o1 = outerPos, o2 = outerPos + groupValue;
             outerPos = o2;
             let innerPos = 0;
             (i
-                ? items.sort((a, b) => innerOrder.get(a[innerChannel]) - innerOrder.get(b[innerChannel]))
+                ? items.sort((a, b) => (innerOrder.get(a[innerChannel]) ?? 0) -
+                    (innerOrder.get(b[innerChannel]) ?? 0))
                 : items).forEach((d) => {
                 const iv = resolveProp(d[value], d);
                 const i1 = innerPos, i2 = innerPos + iv;
@@ -237,9 +245,17 @@ function stackMosaic({ data, x, y, value, fx, fy, ...rest }, { outer, inner }, {
         y2: S.y2
     };
 }
+/**
+ * creates a mosaic layout with the outer (width) dimension along x and
+ * the inner (height) dimension along y
+ */
 export function stackMosaicX(args, opts) {
     return stackMosaic(args, { outer: 'x', inner: 'y' }, opts);
 }
+/**
+ * creates a mosaic layout with the outer (height) dimension along y and
+ * the inner (width) dimension along x
+ */
 export function stackMosaicY(args, opts) {
     return stackMosaic(args, { outer: 'y', inner: 'x' }, opts);
 }

package/dist/transforms/window.d.ts

@@ -1,12 +1,21 @@
 import { type ReducerName } from '../helpers/reduce.js';
 import type { DataRecord, TransformArg } from '../types/index.js';
-type WindowOptions = {
+export type WindowAnchor = 'start' | 'middle' | 'end';
+export type WindowOptions = {
+    /** the window size (number of data points) */
     k: number;
-    interval: string;
-    anchor: 'start' | 'middle' | 'end';
-    reduce: ReducerName;
-    strict: boolean;
+    /** a time interval string to use instead of a fixed window size */
+    interval?: string;
+    /** where to align the window relative to the current data point */
+    anchor?: WindowAnchor;
+    /** the reducer function to apply within each window (e.g. "mean", "median", "sum") */
+    reduce?: ReducerName;
+    /** if true, return null when the window has fewer than k values */
+    strict?: boolean | number;
 };
+/**
+ * applies a sliding window reducer to the x channel
+ */
 export declare function windowX(args: TransformArg<DataRecord>, options: WindowOptions): {
     filter?: import("../types/index.js").ConstantAccessor<boolean, Record<string | symbol, import("../types/data.js").RawValue>>;
     facet?: "auto" | "include" | "exclude" | undefined;
@@ -18,6 +27,16 @@ export declare function windowX(args: TransformArg<DataRecord>, options: WindowO
     dodgeY?: import("./dodge.js").DodgeYOptions | undefined;
     fill?: import("../types/channel.js").ChannelAccessor<Record<string | symbol, import("../types/data.js").RawValue>>;
     fillOpacity?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data.js").RawValue>>;
+    fontFamily?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontFamily, Record<string | symbol, import("../types/data.js").RawValue>>;
+    fontSize?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontSize<number>, Record<string | symbol, import("../types/data.js").RawValue>>;
+    fontStyle?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontStyle, Record<string | symbol, import("../types/data.js").RawValue>>;
+    fontVariant?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontVariant, Record<string | symbol, import("../types/data.js").RawValue>>;
+    fontWeight?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontWeight, Record<string | symbol, import("../types/data.js").RawValue>>;
+    letterSpacing?: import("../types/index.js").ConstantAccessor<import("csstype").Property.LetterSpacing<0 | (string & {})>, Record<string | symbol, import("../types/data.js").RawValue>>;
+    wordSpacing?: import("../types/index.js").ConstantAccessor<import("csstype").Property.WordSpacing<0 | (string & {})>, Record<string | symbol, import("../types/data.js").RawValue>>;
+    textAnchor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.TextAnchor, Record<string | symbol, import("../types/data.js").RawValue>>;
+    textTransform?: import("../types/index.js").ConstantAccessor<import("csstype").Property.TextTransform, Record<string | symbol, import("../types/data.js").RawValue>>;
+    textDecoration?: import("../types/index.js").ConstantAccessor<import("csstype").Property.TextDecoration<0 | (string & {})>, Record<string | symbol, import("../types/data.js").RawValue>>;
     sort?: ((a: import("../types/data.js").RawValue, b: import("../types/data.js").RawValue) => number) | {
         channel: string;
         order?: "ascending" | "descending";
@@ -31,50 +50,115 @@ export declare function windowX(args: TransformArg<DataRecord>, options: WindowO
     opacity?: import("../types/channel.js").ChannelAccessor<Record<string | symbol, import("../types/data.js").RawValue>>;
     strokeDasharray?: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/data.js").RawValue>>;
     strokeDashoffset?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data.js").RawValue>>;
+    blend?: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, Record<string | symbol, import("../types/data.js").RawValue>>;
     mixBlendMode?: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, Record<string | symbol, import("../types/data.js").RawValue>>;
     clipPath?: string | undefined;
     mask?: string | undefined;
     imageFilter?: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/data.js").RawValue>>;
     shapeRendering?: import("../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, Record<string | symbol, import("../types/data.js").RawValue>>;
     paintOrder?: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/data.js").RawValue>>;
-    onclick?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondblclick?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseup?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmousedown?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmousemove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseout?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointercancel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerdown?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerup?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointermove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerout?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondrag?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondrop?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragstart?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragend?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchstart?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchmove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchend?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchcancel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    oncontextmenu?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onwheel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
+    onclick?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ondblclick?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onmouseup?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onmousedown?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onmouseenter?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onmousemove?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onmouseleave?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onmouseout?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onmouseover?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onpointercancel?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onpointerdown?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onpointerup?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onpointerenter?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onpointerleave?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onpointermove?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onpointerover?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onpointerout?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ondrag?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ondrop?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ondragstart?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ondragenter?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ondragleave?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ondragover?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ondragend?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ontouchstart?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ontouchmove?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ontouchend?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ontouchcancel?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    oncontextmenu?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onwheel?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
     class?: string | undefined;
     style?: string | undefined;
     cursor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Record<string | symbol, import("../types/data.js").RawValue>>;
+    title?: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/data.js").RawValue>>;
     data: {
         [x: string]: import("../types/data.js").RawValue;
         [x: symbol]: import("../types/data.js").RawValue;
     }[];
 };
+/**
+ * applies a sliding window reducer to the y channel
+ */
 export declare function windowY(args: TransformArg<DataRecord>, options: WindowOptions): {
     filter?: import("../types/index.js").ConstantAccessor<boolean, Record<string | symbol, import("../types/data.js").RawValue>>;
     facet?: "auto" | "include" | "exclude" | undefined;
@@ -86,6 +170,16 @@ export declare function windowY(args: TransformArg<DataRecord>, options: WindowO
     dodgeY?: import("./dodge.js").DodgeYOptions | undefined;
     fill?: import("../types/channel.js").ChannelAccessor<Record<string | symbol, import("../types/data.js").RawValue>>;
     fillOpacity?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data.js").RawValue>>;
+    fontFamily?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontFamily, Record<string | symbol, import("../types/data.js").RawValue>>;
+    fontSize?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontSize<number>, Record<string | symbol, import("../types/data.js").RawValue>>;
+    fontStyle?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontStyle, Record<string | symbol, import("../types/data.js").RawValue>>;
+    fontVariant?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontVariant, Record<string | symbol, import("../types/data.js").RawValue>>;
+    fontWeight?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontWeight, Record<string | symbol, import("../types/data.js").RawValue>>;
+    letterSpacing?: import("../types/index.js").ConstantAccessor<import("csstype").Property.LetterSpacing<0 | (string & {})>, Record<string | symbol, import("../types/data.js").RawValue>>;
+    wordSpacing?: import("../types/index.js").ConstantAccessor<import("csstype").Property.WordSpacing<0 | (string & {})>, Record<string | symbol, import("../types/data.js").RawValue>>;
+    textAnchor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.TextAnchor, Record<string | symbol, import("../types/data.js").RawValue>>;
+    textTransform?: import("../types/index.js").ConstantAccessor<import("csstype").Property.TextTransform, Record<string | symbol, import("../types/data.js").RawValue>>;
+    textDecoration?: import("../types/index.js").ConstantAccessor<import("csstype").Property.TextDecoration<0 | (string & {})>, Record<string | symbol, import("../types/data.js").RawValue>>;
     sort?: ((a: import("../types/data.js").RawValue, b: import("../types/data.js").RawValue) => number) | {
         channel: string;
         order?: "ascending" | "descending";
@@ -99,48 +193,109 @@ export declare function windowY(args: TransformArg<DataRecord>, options: WindowO
     opacity?: import("../types/channel.js").ChannelAccessor<Record<string | symbol, import("../types/data.js").RawValue>>;
     strokeDasharray?: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/data.js").RawValue>>;
     strokeDashoffset?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data.js").RawValue>>;
+    blend?: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, Record<string | symbol, import("../types/data.js").RawValue>>;
     mixBlendMode?: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, Record<string | symbol, import("../types/data.js").RawValue>>;
     clipPath?: string | undefined;
     mask?: string | undefined;
     imageFilter?: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/data.js").RawValue>>;
     shapeRendering?: import("../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, Record<string | symbol, import("../types/data.js").RawValue>>;
     paintOrder?: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/data.js").RawValue>>;
-    onclick?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondblclick?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseup?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmousedown?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmousemove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseout?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointercancel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerdown?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerup?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointermove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerout?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondrag?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondrop?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragstart?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragend?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchstart?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchmove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchend?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchcancel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    oncontextmenu?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onwheel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
+    onclick?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ondblclick?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onmouseup?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onmousedown?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onmouseenter?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onmousemove?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onmouseleave?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onmouseout?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onmouseover?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onpointercancel?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onpointerdown?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onpointerup?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onpointerenter?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onpointerleave?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onpointermove?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onpointerover?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onpointerout?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ondrag?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ondrop?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ondragstart?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ondragenter?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ondragleave?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ondragover?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ondragend?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ontouchstart?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ontouchmove?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ontouchend?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    ontouchcancel?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    oncontextmenu?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
+    onwheel?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: Record<string | symbol, import("../types/data.js").RawValue>, index: number) => void) | undefined;
     class?: string | undefined;
     style?: string | undefined;
     cursor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Record<string | symbol, import("../types/data.js").RawValue>>;
+    title?: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/data.js").RawValue>>;
     data: {
         [x: string]: import("../types/data.js").RawValue;
         [x: symbol]: import("../types/data.js").RawValue;
     }[];
 };
-export {};

package/dist/transforms/window.js

@@ -3,16 +3,22 @@ import { isValid } from '../helpers/index.js';
 import { mayberReducer } from '../helpers/reduce.js';
 import { resolveChannel } from '../helpers/resolve.js';
 import { groups as d3Groups } from 'd3-array';
+/**
+ * applies a sliding window reducer to the x channel
+ */
 export function windowX(args, options) {
     return windowDim('x', args, options);
 }
+/**
+ * applies a sliding window reducer to the y channel
+ */
 export function windowY(args, options) {
     return windowDim('y', args, options);
 }
 function windowDim(dim, { data, ...channels }, options) {
     const { anchor = 'middle', reduce = 'mean', strict = false } = options;
-    let { k, interval } = options;
-    interval = maybeInterval(interval, 'time');
+    let { k } = options;
+    const interval = options.interval ? maybeInterval(options.interval) : undefined;
     // we only change the data, but not the
     if (!((k = Math.floor(k)) > 0))
         throw new Error(`invalid k: ${k}`);

package/dist/types/axes.d.ts

@@ -0,0 +1,43 @@
+import type * as CSS from 'csstype';
+import type { ChannelAccessor, ConstantAccessor, DataRecord, RawValue } from './index.js';
+export type AxisTextAnchor = 'start' | 'middle' | 'end';
+export type AxisTickDatum<TKeyRaw extends symbol = symbol, TKeyIndex extends symbol = symbol> = DataRecord & {
+    [K in TKeyRaw]: RawValue;
+} & {
+    [K in TKeyIndex]: number;
+};
+export type AxisXTick<TDatum extends DataRecord = DataRecord> = TDatum & {
+    hidden: boolean;
+    dx: number;
+    dy: number;
+    x: number;
+    text: string[];
+    element: SVGTextElement | null;
+};
+export type AxisYTick<TDatum extends DataRecord = DataRecord> = TDatum & {
+    hidden: boolean;
+    dx: number;
+    dy: number;
+    y: number;
+    text: string | string[];
+    element: SVGTextElement | null;
+};
+export type BaseAxisXOptions = Record<string | symbol, any> & {
+    dx?: ConstantAccessor<number>;
+    dy?: ConstantAccessor<number>;
+    filter?: ChannelAccessor;
+    wordwrap?: boolean;
+    fontWeight?: ConstantAccessor<CSS.Property.FontWeight>;
+    textAnchor?: ConstantAccessor<AxisTextAnchor> | 'auto';
+    removeDuplicateTicks?: boolean;
+    anchor?: ConstantAccessor<'start' | 'end'>;
+    style?: string;
+};
+export type BaseAxisYOptions = Record<string | symbol, any> & {
+    dx?: ConstantAccessor<number>;
+    dy?: ConstantAccessor<number>;
+    filter?: ChannelAccessor;
+    fontWeight?: ConstantAccessor<CSS.Property.FontWeight>;
+    textAnchor?: ConstantAccessor<AxisTextAnchor>;
+    style?: string;
+};

package/dist/types/axes.js

@@ -0,0 +1 @@
+export {};

package/dist/types/channel.d.ts

@@ -1,12 +1,40 @@
 import type { ConstantAccessor, RawValue } from './index.js';
-export type Channels<T> = Record<string | symbol, ChannelAccessor<T> | ConstantAccessor<T, string | number | boolean | symbol>>;
+/** a partial record of channel names to their accessor definitions */
+export type Channels<T = Record<string | symbol, RawValue>> = Partial<Record<string | symbol, ChannelAccessor<T> | ConstantAccessor<RawValue, T>>>;
+type BivariantCallback<TArgs extends unknown[], TResult> = {
+    bivarianceHack(...args: TArgs): TResult;
+}['bivarianceHack'];
+/** channel accessor callback receiving a typed datum */
+export type ChannelValueAccessor<T = Record<string | symbol, RawValue>> = BivariantCallback<[
+    d: T,
+    index: number
+], RawValue>;
+/** plain objects are allowed as constants, except accessor option objects with `value`/`scale` keys */
+export type ChannelConstantObject = object & {
+    value?: never;
+    scale?: never;
+};
+/** constant channel values (non-accessor) */
+export type ChannelConstantValue = Exclude<RawValue, object> | Date | ChannelConstantObject | null | undefined;
+/**
+ * a channel accessor: either a simple channel value, or an object with
+ * a value and an optional scale override
+ */
 export type ChannelAccessor<T = Record<string | symbol, RawValue>> = ChannelValue<T> | {
     /** the channel value */
     value: ChannelValue<T>;
     /** you can bypass the scale by passing null */
     scale: boolean | null;
 };
-export type ChannelValue<T = Record<string | symbol, RawValue>> = RawValue | keyof T | ((d: T, index: number) => RawValue) | null | undefined;
+/**
+ * the value for a channel: a constant, a data field name, an accessor
+ * function, or null/undefined to leave the channel unset
+ */
+export type ChannelValue<T = Record<string | symbol, RawValue>> = ChannelConstantValue | keyof T | ChannelValueAccessor<T> | null | undefined;
+/** the name of a channel that is bound to a scale */
 export type ScaledChannelName = 'fill' | 'fillOpacity' | 'opacity' | 'r' | 'length' | 'stroke' | 'strokeOpacity' | 'symbol' | 'fx' | 'fy' | 'x' | 'x1' | 'x2' | 'y' | 'y1' | 'y2';
+/** maps a scaled channel name to its output type (string for color/symbol, number otherwise) */
 export type ScaledChannelType<T extends ScaledChannelName> = T extends 'fill' | 'stroke' | 'symbol' ? string : number;
+/** all channel names, including non-scaled channels like z, sort, filter, and interval */
 export type ChannelName = ScaledChannelName | 'z' | 'sort' | 'filter' | 'interval';
+export {};

package/dist/types/data.d.ts

@@ -1,18 +1,31 @@
 import type { ScaledChannelName, ScaledChannelType } from './channel.js';
+/** a raw data value that can be used in channels */
 export type RawValue = number | Date | boolean | string | symbol | object | null;
+/** a data record passed to marks; generic over the user's row shape */
 export type DataRecord<T = Record<string | symbol, RawValue>> = T;
+/** a data record after channel accessors have been resolved to concrete values */
 export type ResolvedDataRecord<T = Record<string | symbol, RawValue>> = Partial<Record<ScaledChannelName, any>> & {
+    /** the original data record before resolution */
     datum: DataRecord<T>;
+    /** the index of this record in the original data array */
     index: number;
 };
+/** a data record after scale functions have been applied to channel values */
 export type ScaledDataRecord<T = Record<string | symbol, RawValue>> = Partial<{
     [K in ScaledChannelName]?: ScaledChannelType<K>;
 }> & {
+    /** horizontal pixel offset applied after scaling */
     dx: number;
+    /** vertical pixel offset applied after scaling */
     dy: number;
+    /** the original data record */
     datum: DataRecord<T>;
+    /** the resolved (pre-scaling) channel values */
     resolved: ResolvedDataRecord<T>;
-    valid: Boolean;
+    /** whether this record has valid values for all required channels */
+    valid: boolean;
+    /** the index of this record in the original data array */
     index: number;
 };
+/** a data row as passed by the user; can be a record, a raw value, a coordinate pair, or null */
 export type DataRow<T = Record<string | symbol, RawValue>> = DataRecord<T> | RawValue | [number, number] | null;