svelteplot 0.10.2 → 0.10.3-pr-370.1

package/dist/transforms/sort.d.ts

@@ -1,10 +1,13 @@
 import type { DataRow, TransformArg } from '../types/index.js';
-export declare const SORT_KEY: unique symbol;
-export declare const IS_SORTED: unique symbol;
+export declare const SORT_KEY: any;
+export declare const IS_SORTED: any;
+/**
+ * sorts the data according to the sort channel option; supports channel
+ * accessors, comparator functions, and {channel, order} objects
+ */
 export declare function sort<T>({ data, ...channels }: TransformArg<T>, options?: {
     reverse?: boolean;
 }): {
-    [IS_SORTED]: string | number | true | symbol | object;
     sort: null;
     filter?: import("../types/index.js").ConstantAccessor<boolean, T>;
     facet?: "auto" | "include" | "exclude" | undefined;
@@ -12,8 +15,8 @@ export declare function sort<T>({ data, ...channels }: TransformArg<T>, options?
     fy?: import("../types/channel.js").ChannelAccessor<T>;
     dx?: import("../types/index.js").ConstantAccessor<number, T>;
     dy?: import("../types/index.js").ConstantAccessor<number, T>;
-    dodgeX?: import("./dodge.js").DodgeXOptions | undefined;
-    dodgeY?: import("./dodge.js").DodgeYOptions | undefined;
+    dodgeX?: DodgeXOptions;
+    dodgeY?: DodgeYOptions;
     fill?: import("../types/channel.js").ChannelAccessor<T>;
     fillOpacity?: import("../types/index.js").ConstantAccessor<number, T>;
     stroke?: import("../types/channel.js").ChannelAccessor<T>;
@@ -64,9 +67,7 @@ export declare function sort<T>({ data, ...channels }: TransformArg<T>, options?
     class?: string | undefined;
     style?: string | undefined;
     cursor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, T>;
-    data: T[] | Omit<T & {
-        [SORT_KEY]: string | number | Date;
-    }, typeof SORT_KEY>[];
+    data: any;
 } | {
     filter?: import("../types/index.js").ConstantAccessor<boolean, T>;
     facet?: "auto" | "include" | "exclude" | undefined;
@@ -74,14 +75,14 @@ export declare function sort<T>({ data, ...channels }: TransformArg<T>, options?
     fy?: import("../types/channel.js").ChannelAccessor<T>;
     dx?: import("../types/index.js").ConstantAccessor<number, T>;
     dy?: import("../types/index.js").ConstantAccessor<number, T>;
-    dodgeX?: import("./dodge.js").DodgeXOptions | undefined;
-    dodgeY?: import("./dodge.js").DodgeYOptions | undefined;
+    dodgeX?: DodgeXOptions;
+    dodgeY?: DodgeYOptions;
     fill?: import("../types/channel.js").ChannelAccessor<T>;
     fillOpacity?: import("../types/index.js").ConstantAccessor<number, T>;
-    sort?: ((a: import("../types/data.js").RawValue, b: import("../types/data.js").RawValue) => number) | {
+    sort?: {
         channel: string;
         order?: "ascending" | "descending";
-    } | import("../types/index.js").ConstantAccessor<import("../types/data.js").RawValue, T>;
+    } | ((a: import("../types/data.js").RawValue, b: import("../types/data.js").RawValue) => number) | import("../types/index.js").ConstantAccessor<import("../types/data.js").RawValue, T>;
     stroke?: import("../types/channel.js").ChannelAccessor<T>;
     strokeWidth?: import("../types/index.js").ConstantAccessor<number, T>;
     strokeOpacity?: import("../types/index.js").ConstantAccessor<number, T>;
@@ -139,15 +140,14 @@ export declare function shuffle({ data, ...channels }: TransformArg<DataRow[]>,
     seed?: number;
 }): {
     sort: null;
-    [IS_SORTED]: boolean;
     filter?: import("../types/index.js").ConstantAccessor<boolean, DataRow[]>;
     facet?: "auto" | "include" | "exclude" | undefined;
     fx?: import("../types/channel.js").ChannelAccessor<DataRow[]>;
     fy?: import("../types/channel.js").ChannelAccessor<DataRow[]>;
     dx?: import("../types/index.js").ConstantAccessor<number, DataRow[]>;
     dy?: import("../types/index.js").ConstantAccessor<number, DataRow[]>;
-    dodgeX?: import("./dodge.js").DodgeXOptions | undefined;
-    dodgeY?: import("./dodge.js").DodgeYOptions | undefined;
+    dodgeX?: DodgeXOptions;
+    dodgeY?: DodgeYOptions;
     fill?: import("../types/channel.js").ChannelAccessor<DataRow[]>;
     fillOpacity?: import("../types/index.js").ConstantAccessor<number, DataRow[]>;
     stroke?: import("../types/channel.js").ChannelAccessor<DataRow[]>;
@@ -205,15 +205,14 @@ export declare function shuffle({ data, ...channels }: TransformArg<DataRow[]>,
  */
 export declare function reverse({ data, ...channels }: TransformArg<DataRow[]>): {
     sort: null;
-    [IS_SORTED]: boolean;
     filter?: import("../types/index.js").ConstantAccessor<boolean, DataRow[]>;
     facet?: "auto" | "include" | "exclude" | undefined;
     fx?: import("../types/channel.js").ChannelAccessor<DataRow[]>;
     fy?: import("../types/channel.js").ChannelAccessor<DataRow[]>;
     dx?: import("../types/index.js").ConstantAccessor<number, DataRow[]>;
     dy?: import("../types/index.js").ConstantAccessor<number, DataRow[]>;
-    dodgeX?: import("./dodge.js").DodgeXOptions | undefined;
-    dodgeY?: import("./dodge.js").DodgeYOptions | undefined;
+    dodgeX?: DodgeXOptions;
+    dodgeY?: DodgeYOptions;
     fill?: import("../types/channel.js").ChannelAccessor<DataRow[]>;
     fillOpacity?: import("../types/index.js").ConstantAccessor<number, DataRow[]>;
     stroke?: import("../types/channel.js").ChannelAccessor<DataRow[]>;
@@ -264,5 +263,5 @@ export declare function reverse({ data, ...channels }: TransformArg<DataRow[]>):
     class?: string | undefined;
     style?: string | undefined;
     cursor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, DataRow[]>;
-    data: DataRow[][];
+    data: any;
 };

package/dist/transforms/sort.js

@@ -4,6 +4,10 @@ import { shuffler } from 'd3-array';
 import { randomLcg } from 'd3-random';
 export const SORT_KEY = Symbol('sortKey');
 export const IS_SORTED = Symbol('isSorted');
+/**
+ * sorts the data according to the sort channel option; supports channel
+ * accessors, comparator functions, and {channel, order} objects
+ */
 export function sort({ data, ...channels }, options = {}) {
     if (!Array.isArray(data))
         return { data, ...channels };

package/dist/transforms/stack.d.ts

@@ -1,32 +1,52 @@
 import type { ChannelAccessor, TransformArg } from '../types/index.js';
+/** the order in which series are stacked */
 export type StackOrder = 'none' | 'appearance' | 'inside-out' | 'sum';
+/** the offset method used to position stacked values */
 export type StackOffset = 'none' | 'wiggle' | 'center' | 'normalize' | 'diverging';
+/** options for the stack transform, or false to disable stacking */
 export type StackOptions = {
+    /** the offset method, or null for the default (zero baseline) */
     offset: null | StackOffset;
+    /** the stack order, or null for the default (input order) */
     order: null | StackOrder;
+    /** if true, reverse the stack order */
     reverse: boolean;
 } | false;
+/**
+ * stacks data along the y dimension, producing y1 and y2 channels
+ */
 export declare function stackY<T>({ data, ...channels }: TransformArg<T>, opts?: Partial<StackOptions>): TransformArg<T>;
+/**
+ * stacks data along the x dimension, producing x1 and x2 channels
+ */
 export declare function stackX<T>({ data, ...channels }: TransformArg<T>, opts?: Partial<StackOptions>): TransformArg<T>;
+/**
+ * creates a mosaic layout with the outer (width) dimension along x and
+ * the inner (height) dimension along y
+ */
 export declare function stackMosaicX<T>(args: any, opts: any): {
     fx: ChannelAccessor<unknown>;
     fy: ChannelAccessor<unknown>;
     data: unknown[];
-    x: symbol;
-    x1: symbol;
-    x2: symbol;
-    y: symbol;
-    y1: symbol;
-    y2: symbol;
+    x: any;
+    x1: any;
+    x2: any;
+    y: any;
+    y1: any;
+    y2: any;
 };
+/**
+ * creates a mosaic layout with the outer (height) dimension along y and
+ * the inner (width) dimension along x
+ */
 export declare function stackMosaicY<T>(args: any, opts: any): {
     fx: ChannelAccessor<unknown>;
     fy: ChannelAccessor<unknown>;
     data: unknown[];
-    x: symbol;
-    x1: symbol;
-    x2: symbol;
-    y: symbol;
-    y1: symbol;
-    y2: symbol;
+    x: any;
+    x1: any;
+    x2: any;
+    y: any;
+    y1: any;
+    y2: any;
 };

package/dist/transforms/stack.js

@@ -158,9 +158,15 @@ function stackXY(byDim, data, channels, options) {
     }
     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));
 }
@@ -237,9 +243,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,146 +1,23 @@
 import { type ReducerName } from '../helpers/reduce.js';
 import type { DataRecord, TransformArg } from '../types/index.js';
 type WindowOptions = {
+    /** the window size (number of data points) */
     k: number;
+    /** 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: 'start' | 'middle' | 'end';
+    /** 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;
 };
-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;
-    fx?: import("../types/channel.js").ChannelAccessor<Record<string | symbol, import("../types/data.js").RawValue>>;
-    fy?: import("../types/channel.js").ChannelAccessor<Record<string | symbol, import("../types/data.js").RawValue>>;
-    dx?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data.js").RawValue>>;
-    dy?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data.js").RawValue>>;
-    dodgeX?: import("./dodge.js").DodgeXOptions | undefined;
-    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>>;
-    sort?: ((a: import("../types/data.js").RawValue, b: import("../types/data.js").RawValue) => number) | {
-        channel: string;
-        order?: "ascending" | "descending";
-    } | import("../types/index.js").ConstantAccessor<import("../types/data.js").RawValue, Record<string | symbol, import("../types/data.js").RawValue>>;
-    stroke?: import("../types/channel.js").ChannelAccessor<Record<string | symbol, import("../types/data.js").RawValue>>;
-    strokeWidth?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data.js").RawValue>>;
-    strokeOpacity?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data.js").RawValue>>;
-    strokeLinejoin?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, Record<string | symbol, import("../types/data.js").RawValue>>;
-    strokeLinecap?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, Record<string | symbol, import("../types/data.js").RawValue>>;
-    strokeMiterlimit?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data.js").RawValue>>;
-    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>>;
-    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;
-    class?: string | undefined;
-    style?: string | undefined;
-    cursor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Record<string | symbol, import("../types/data.js").RawValue>>;
-    data: {
-        [x: string]: import("../types/data.js").RawValue;
-        [x: symbol]: import("../types/data.js").RawValue;
-    }[];
-};
-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;
-    fx?: import("../types/channel.js").ChannelAccessor<Record<string | symbol, import("../types/data.js").RawValue>>;
-    fy?: import("../types/channel.js").ChannelAccessor<Record<string | symbol, import("../types/data.js").RawValue>>;
-    dx?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data.js").RawValue>>;
-    dy?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data.js").RawValue>>;
-    dodgeX?: import("./dodge.js").DodgeXOptions | undefined;
-    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>>;
-    sort?: ((a: import("../types/data.js").RawValue, b: import("../types/data.js").RawValue) => number) | {
-        channel: string;
-        order?: "ascending" | "descending";
-    } | import("../types/index.js").ConstantAccessor<import("../types/data.js").RawValue, Record<string | symbol, import("../types/data.js").RawValue>>;
-    stroke?: import("../types/channel.js").ChannelAccessor<Record<string | symbol, import("../types/data.js").RawValue>>;
-    strokeWidth?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data.js").RawValue>>;
-    strokeOpacity?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data.js").RawValue>>;
-    strokeLinejoin?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, Record<string | symbol, import("../types/data.js").RawValue>>;
-    strokeLinecap?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, Record<string | symbol, import("../types/data.js").RawValue>>;
-    strokeMiterlimit?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data.js").RawValue>>;
-    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>>;
-    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;
-    class?: string | undefined;
-    style?: string | undefined;
-    cursor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, 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 x channel
+ */
+export declare function windowX(args: TransformArg<DataRecord>, options: WindowOptions): any;
+/**
+ * applies a sliding window reducer to the y channel
+ */
+export declare function windowY(args: TransformArg<DataRecord>, options: WindowOptions): any;
 export {};

package/dist/transforms/window.js

@@ -3,9 +3,15 @@ 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);
 }

package/dist/types/channel.d.ts

@@ -1,12 +1,24 @@
 import type { ConstantAccessor, RawValue } from './index.js';
+/** a record of channel names to their accessor definitions */
 export type Channels<T> = Record<string | symbol, ChannelAccessor<T> | ConstantAccessor<T, string | number | boolean | symbol>>;
+/**
+ * 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;
 };
+/**
+ * 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>> = RawValue | keyof T | ((d: T, index: number) => RawValue) | 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';

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>;
+    /** 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;

package/dist/types/facet.d.ts

@@ -1,6 +1,9 @@
 import type { ChannelAccessor, ChannelName, DataRecord, RawValue } from './index.js';
+/** the state of a single facet panel within a faceted plot */
 type FacetState = {
+    /** the current horizontal facet value */
     fx: RawValue;
+    /** the current vertical facet value */
     fy: RawValue;
     /**
      * True, if the facet is the leftmost in its row
@@ -39,12 +42,14 @@ type FacetState = {
  * Test if the given data record is visible in the current facet.
  */
 type TestFacetFunction = (datum: DataRecord<any>, channels: Record<ChannelName, ChannelAccessor>) => boolean;
+/** context provided to marks for facet-aware filtering and state access */
 export type FacetContext = {
     /**
      * Returns a stateful function that tests whether a specific data
      * record is visible in the current facet or not.
      */
     getTestFacet: () => TestFacetFunction;
+    /** returns the current facet panel state (position, edge flags) */
     getFacetState: () => FacetState;
 };
 export {};

package/dist/types/index.d.ts

@@ -4,7 +4,9 @@ import type { MarkerShape } from '../marks/helpers/Marker.svelte';
 import type { Channels, ScaledChannelName } from './channel.js';
 import type { RawValue } from './data.js';
 import type { BaseMarkProps } from './mark.js';
+/** a generic record type used when the specific mark options type is not known */
 export type GenericMarkOptions = Record<string | symbol, any>;
+/** the name of a d3 curve interpolation method */
 export type CurveName = 'basis' | 'basis-closed' | 'basis-open' | 'bundle' | 'bump-x' | 'bump-y' | 'cardinal' | 'cardinal-closed' | 'cardinal-open' | 'catmull-rom' | 'catmull-rom-closed' | 'catmull-rom-open' | 'linear' | 'linear-closed' | 'monotone-x' | 'monotone-y' | 'natural' | 'step' | 'step-after' | 'step-before';
 export type MarkerOptions = {
     /**
@@ -28,36 +30,52 @@ export type MarkerOptions = {
      */
     markerScale?: ConstantAccessor<number>;
 };
+/** a value that is either a constant or a function that computes a per-datum value */
 export type ConstantAccessor<K, T = Record<string | symbol, RawValue>> = K | ((d: T, index: number) => K) | null | undefined;
+/** the input argument to a data transform: data array plus channel mappings and mark props */
 export type TransformArg<T> = Channels<T> & BaseMarkProps<T> & {
     data: T[];
 };
+/** the input argument to a map transform: data array plus channel mappings */
 export type MapArg<T> = Channels<T> & {
     data: T[];
 };
+/** transform input for raw data rows (before recordization) */
 export type TransformArgsRow<T extends RawValue | object> = Partial<Channels<T>> & {
     data: T[];
 };
+/** transform input for data records (after recordization) */
 export type TransformArgsRecord<T extends object> = Partial<Channels<T>> & {
     data: T[];
 };
+/** the return type of a transform, ensuring data is always present */
 export type TransformReturn<C extends TransformArg<T>, T> = C & Required<Pick<Channels<T>, 'data'>>;
+/** writable stores used by marks to contribute to automatic margin computation */
 export type AutoMarginStores = {
+    /** per-mark contributions to the top margin */
     autoMarginTop: Writable<Map<string, number>>;
+    /** per-mark contributions to the left margin */
     autoMarginLeft: Writable<Map<string, number>>;
+    /** per-mark contributions to the right margin */
     autoMarginRight: Writable<Map<string, number>>;
+    /** per-mark contributions to the bottom margin */
     autoMarginBottom: Writable<Map<string, number>>;
 };
+/** a function that maps source values (S) to target values (T) for the given indices (I) */
 export type MapIndexFunction = (I: number[], S: RawValue[], T: RawValue[]) => void;
+/** an object implementing the mapIndex interface for custom map transforms */
 export type MapIndexObject = {
+    /** the function that performs the index-based mapping */
     mapIndex: MapIndexFunction;
 };
+/** a named map method, a custom mapping function, or a MapIndexObject */
 export type MapMethod = 'cumsum' | 'rank' | 'quantile' | ((I: number[], S: number[]) => number[]) | MapIndexObject;
 /**
  * An object specifying mapping methods for one or more scaled channels
  * e.g. ```{ x: 'rank' }```
  */
 export type MapOptions = Partial<Record<ScaledChannelName, MapMethod>>;
+/** a record indicating which scaled channels are actively used by a mark */
 export type UsedScales = Record<ScaledChannelName, boolean>;
 export * from './channel';
 export * from './colorScheme';