svelteplot 0.10.2 → 0.10.3-pr-370.1

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

@@ -1,8 +1,11 @@
 import type { BaseMarkProps, ChannelAccessor } from '../../types/index.js';
 type RegressionType = 'linear' | 'quad' | 'poly' | 'exp' | 'log' | 'pow' | 'loess';
 export type RegressionMarkProps = BaseMarkProps & {
+    /** the horizontal position channel; bound to the x scale */
     x: ChannelAccessor;
+    /** the vertical position channel; bound to the y scale */
     y: ChannelAccessor;
+    /** the regression model type */
     type: RegressionType;
     /**
      * If order is specified, sets the regression's order to the specified number.
@@ -14,8 +17,11 @@ export type RegressionMarkProps = BaseMarkProps & {
      * it may have little predictive power for data outside of your domain.
      */
     order: number;
+    /** the base for logarithmic regression */
     base: number;
+    /** the bandwidth for LOESS regression, as a fraction of the data range (0 to 1) */
     span: number;
+    /** the confidence level for confidence bands (e.g. 0.95 for 95% confidence) */
     confidence: number;
 };
 declare const Regression: import("svelte").Component<any, {}, "">;

package/dist/transforms/bollinger.d.ts

@@ -9,6 +9,14 @@ export type BollingerOptions = {
      */
     k?: number;
 };
+/**
+ * computes Bollinger bands for the x channel, producing x1 (lower), x (mean),
+ * and x2 (upper) channels
+ */
 export declare function bollingerX<T>(args: TransformArg<T>, options?: BollingerOptions): TransformArg<T>;
+/**
+ * computes Bollinger bands for the y channel, producing y1 (lower), y (mean),
+ * and y2 (upper) channels
+ */
 export declare function bollingerY<T>(args: TransformArg<T>, options?: BollingerOptions): TransformArg<T>;
 export declare function bollingerDim<T>(dim: 'x' | 'y', { data, ...channels }: TransformArg<T>, options?: BollingerOptions): TransformArg<T>;

package/dist/transforms/bollinger.js

@@ -1,7 +1,15 @@
 import { resolveChannel } from '../helpers/resolve.js';
+/**
+ * computes Bollinger bands for the x channel, producing x1 (lower), x (mean),
+ * and x2 (upper) channels
+ */
 export function bollingerX(args, options = {}) {
     return bollingerDim('x', args, options);
 }
+/**
+ * computes Bollinger bands for the y channel, producing y1 (lower), y (mean),
+ * and y2 (upper) channels
+ */
 export function bollingerY(args, options = {}) {
     return bollingerDim('y', args, options);
 }

package/dist/transforms/centroid.d.ts

@@ -1,8 +1,9 @@
 import type { DataRecord, TransformArg } from '../types/index.js';
-declare const CENTROID: unique symbol;
-type WithCentroid<T> = T & {
-    [CENTROID]: [number, number];
-};
+type WithCentroid<T> = T & {};
+/**
+ * computes the geographic centroid of each geometry feature, producing
+ * x (longitude) and y (latitude) channels
+ */
 export declare function geoCentroid<Datum extends DataRecord>({ data, ...options }: {
     data: Datum[];
 } & TransformArg<Datum>): TransformArg<WithCentroid<Datum>>;

package/dist/transforms/centroid.js

@@ -1,6 +1,10 @@
 import { resolveProp } from '../helpers/resolve.js';
 import { geoCentroid as d3GeoCentroid } from 'd3-geo';
 const CENTROID = Symbol('centroid');
+/**
+ * computes the geographic centroid of each geometry feature, producing
+ * x (longitude) and y (latitude) channels
+ */
 export function geoCentroid({ data, ...options }) {
     const transformedData = data.map((d) => ({
         ...d,

package/dist/transforms/dodge.d.ts

@@ -1,17 +1,28 @@
 import type { ScaledDataRecord, TransformArg, PlotState } from '../types';
 type BaseDodgeOptions = {
+    /** the anchor side for placing dodged marks */
     anchor?: string;
+    /** the padding between dodged marks, in pixels */
     padding?: number;
+    /** the radius of dodged marks, in pixels */
     r?: number;
 };
 type AnchorX = 'left' | 'right' | 'middle';
 type AnchorY = 'top' | 'bottom' | 'middle';
+/** options for horizontal dodge positioning; can be an anchor string or a full options object */
 export type DodgeXOptions = AnchorX | (BaseDodgeOptions & {
     anchor?: 'left' | 'right' | 'middle';
 });
+/** options for vertical dodge positioning; can be an anchor string or a full options object */
 export type DodgeYOptions = AnchorY | (BaseDodgeOptions & {
     anchor?: 'top' | 'bottom' | 'middle';
 });
+/**
+ * offsets marks horizontally to avoid overlap, using circle-packing
+ */
 export declare function dodgeX(args: TransformArg<ScaledDataRecord>, plotState: PlotState): ScaledDataRecord[];
+/**
+ * offsets marks vertically to avoid overlap, using circle-packing
+ */
 export declare function dodgeY(args: TransformArg<ScaledDataRecord>, plotState: PlotState): ScaledDataRecord[];
 export {};

package/dist/transforms/dodge.js

@@ -1,5 +1,8 @@
 import IntervalTree from 'interval-tree-1d';
 import { groupFacetsAndZ } from '../helpers/group';
+/**
+ * offsets marks horizontally to avoid overlap, using circle-packing
+ */
 export function dodgeX(args, plotState) {
     if (!args.dodgeX)
         return args.data;
@@ -20,6 +23,9 @@ export function dodgeX(args, plotState) {
     }
     return dodge('x', 'y', anchorFunction, Number(padding), r, args, plotState);
 }
+/**
+ * offsets marks vertically to avoid overlap, using circle-packing
+ */
 export function dodgeY(args, plotState) {
     if (!args.dodgeY)
         return args.data;

package/dist/transforms/interval.d.ts

@@ -9,14 +9,14 @@ export declare function intervalX<T>(args: TransformArg<T>): {
     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>;
@@ -77,14 +77,14 @@ export declare function intervalY<T>(args: TransformArg<T>): {
     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>;

package/dist/transforms/jitter.d.ts

@@ -12,8 +12,17 @@ type JitterOptions = {
     type: 'normal';
     std?: number | string;
 });
+/**
+ * adds random noise to the x channel values
+ */
 export declare function jitterX<T>(args: TransformArg<T>, options: JitterOptions): TransformReturn<T, 'x'>;
+/**
+ * adds random noise to the y channel values
+ */
 export declare function jitterY<T>(args: TransformArg<T>, options: JitterOptions): TransformReturn<T, 'y'>;
 type PositionalScale = 'x' | 'x1' | 'x2' | 'y' | 'y1' | 'y2';
+/**
+ * adds random noise to one or more positional channels
+ */
 export declare function jitter<T, C extends TransformArg<T>>({ data, ...channels }: C, options: Partial<Record<PositionalScale, JitterOptions>>): TransformReturn<C, T>;
 export {};

package/dist/transforms/jitter.js

@@ -10,12 +10,21 @@ const JITTER = {
     y1: Symbol('jitterY1'),
     y2: Symbol('jitterY2')
 };
+/**
+ * adds random noise to the x channel values
+ */
 export function jitterX(args, options) {
     return jitter(args, { x: options });
 }
+/**
+ * adds random noise to the y channel values
+ */
 export function jitterY(args, options) {
     return jitter(args, { y: options });
 }
+/**
+ * adds random noise to one or more positional channels
+ */
 export function jitter({ data, ...channels }, options) {
     const jitterChannels = Object.keys(options).filter((ch) => channels[ch]);
     // if no jitter channels are defined return early

package/dist/transforms/recordize.d.ts

@@ -1,14 +1,19 @@
 import type { TransformArgsRow, TransformArgsRecord, DataRecord, DataRow } from '../types/index.js';
-import { INDEX } from '../constants';
-export declare const X: unique symbol;
-export declare const Y: unique symbol;
-export declare const RAW_VALUE: unique symbol;
-export declare function indexData<T extends object>(data: T[]): (T & {
-    [INDEX]: number;
-})[];
+export declare const X: any;
+export declare const Y: any;
+export declare const RAW_VALUE: any;
+export declare function indexData<T extends object>(data: T[]): (T & {})[];
+/**
+ * takes an array of raw values and returns data records in which the values
+ * are interpreted as the x channel and their index as the y channel
+ */
 export declare function recordizeX<T>({ data, ...channels }: TransformArgsRow<DataRow>, { withIndex }?: {
     withIndex: boolean;
 }): TransformArgsRecord<DataRecord>;
+/**
+ * takes an array of raw values and returns data records in which the values
+ * are interpreted as the y channel and their index as the x channel
+ */
 export declare function recordizeY<T>({ data, ...channels }: TransformArgsRow<DataRow>, { withIndex }?: {
     withIndex: boolean;
 }): TransformArgsRecord<DataRecord>;
@@ -18,4 +23,8 @@ export declare function recordizeY<T>({ data, ...channels }: TransformArgsRow<Da
  * the rest of our code doesn't have to deal with this case anymore.
  */
 export declare function recordizeXY<T>({ data, ...channels }: TransformArgsRow<T>): TransformArgsRecord<T>;
+/**
+ * wraps raw values into data records with index tracking, without
+ * assigning them to a specific positional channel
+ */
 export declare function recordize<T>({ data, ...channels }: TransformArgsRow<T>): TransformArgsRecord<T>;

package/dist/transforms/recordize.js

@@ -6,9 +6,9 @@ export const RAW_VALUE = Symbol('originalValue');
 export function indexData(data) {
     return data.map((d, i) => ({ ...d, [INDEX]: i }));
 }
-/*
- * This transform takes an array of raw values as input and returns data records
- * in which the values are interpreted as x channel and their index as y
+/**
+ * takes an array of raw values and returns data records in which the values
+ * are interpreted as the x channel and their index as the y channel
  */
 export function recordizeX({ data, ...channels }, { withIndex } = { withIndex: true }) {
     const dataIsRawValueArray = !isDataRecord(data[0]) && !Array.isArray(data[0]) && channels.x == null;
@@ -28,9 +28,9 @@ export function recordizeX({ data, ...channels }, { withIndex } = { withIndex: t
     }
     return { data: indexData(data), ...channels };
 }
-/*
- * This transform takes an array of raw values as input and returns data records
- * in which the values are interpreted as y channel and their index as yx
+/**
+ * takes an array of raw values and returns data records in which the values
+ * are interpreted as the y channel and their index as the x channel
  */
 export function recordizeY({ data, ...channels }, { withIndex } = { withIndex: true }) {
     if (!data)
@@ -78,6 +78,10 @@ export function recordizeXY({ data, ...channels }) {
     }
     return { data: data, ...channels };
 }
+/**
+ * wraps raw values into data records with index tracking, without
+ * assigning them to a specific positional channel
+ */
 export function recordize({ data, ...channels }) {
     if (!data)
         return { data, ...channels };

package/dist/transforms/rename.d.ts

@@ -2,7 +2,7 @@ import type { DataRecord } from '../types/index.js';
 import type { ScaledChannelName, TransformArg } from '../types/index.js';
 type RenameChannelsOptions = Partial<Record<ScaledChannelName, ScaledChannelName>>;
 type ReplaceChannelsOptions = Partial<Record<ScaledChannelName, ScaledChannelName[]>>;
-export declare const RENAME: unique symbol;
+export declare const RENAME: any;
 /**
  * renames a channel without modifying the data
  */
@@ -11,5 +11,9 @@ export declare function renameChannels<T>({ data, ...channels }: TransformArg<T,
  * renames a channel and copy the data
  */
 export declare function renameChannelsAndData<T>({ data, ...channels }: TransformArg<T, DataRecord>, options: RenameChannelsOptions): TransformArg<T, DataRecord>;
+/**
+ * copies a channel's accessor to multiple target channels, then removes
+ * the source channel
+ */
 export declare function replaceChannels<T>({ data, ...channels }: TransformArg<T, DataRecord>, options: ReplaceChannelsOptions): TransformArg<T, DataRecord>;
 export {};

package/dist/transforms/rename.js

@@ -33,6 +33,10 @@ export function renameChannelsAndData({ data, ...channels }, options) {
     }
     return renameChannels({ data: newData, ...channels }, options);
 }
+/**
+ * copies a channel's accessor to multiple target channels, then removes
+ * the source channel
+ */
 export function replaceChannels({ data, ...channels }, options) {
     const newChannels = { ...channels };
     for (const [from, to] of Object.entries(options)) {

package/dist/transforms/select.d.ts

@@ -5,6 +5,10 @@ type AtLeastOne<T, U = {
 type SelectOptions = 'first' | 'last' | AtLeastOne<{
     [k in ChannelName]: 'min' | 'max';
 }>;
+/**
+ * selects one datum per group based on the given criteria; use "first"/"last"
+ * for positional selection, or {channel: "min"/"max"} for value-based selection
+ */
 export declare function select({ data, ...channels }: TransformArg<DataRecord>, options: SelectOptions): {
     filter?: import("../types/index.js").ConstantAccessor<boolean, Record<string | symbol, import("../types/data.js").RawValue>>;
     facet?: "auto" | "include" | "exclude" | undefined;
@@ -12,14 +16,14 @@ export declare function select({ data, ...channels }: TransformArg<DataRecord>,
     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;
+    dodgeX?: DodgeXOptions;
+    dodgeY?: DodgeYOptions;
     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) | {
+    sort?: {
         channel: string;
         order?: "ascending" | "descending";
-    } | import("../types/index.js").ConstantAccessor<import("../types/data.js").RawValue, Record<string | symbol, import("../types/data.js").RawValue>>;
+    } | ((a: import("../types/data.js").RawValue, b: import("../types/data.js").RawValue) => number) | 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>>;
@@ -80,14 +84,14 @@ export declare function selectFirst(args: TransformArg<DataRecord>): {
     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;
+    dodgeX?: DodgeXOptions;
+    dodgeY?: DodgeYOptions;
     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) | {
+    sort?: {
         channel: string;
         order?: "ascending" | "descending";
-    } | import("../types/index.js").ConstantAccessor<import("../types/data.js").RawValue, Record<string | symbol, import("../types/data.js").RawValue>>;
+    } | ((a: import("../types/data.js").RawValue, b: import("../types/data.js").RawValue) => number) | 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>>;
@@ -148,14 +152,14 @@ export declare function selectLast(args: TransformArg<DataRecord>): {
     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;
+    dodgeX?: DodgeXOptions;
+    dodgeY?: DodgeYOptions;
     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) | {
+    sort?: {
         channel: string;
         order?: "ascending" | "descending";
-    } | import("../types/index.js").ConstantAccessor<import("../types/data.js").RawValue, Record<string | symbol, import("../types/data.js").RawValue>>;
+    } | ((a: import("../types/data.js").RawValue, b: import("../types/data.js").RawValue) => number) | 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>>;
@@ -206,6 +210,7 @@ export declare function selectLast(args: TransformArg<DataRecord>): {
     cursor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Record<string | symbol, import("../types/data.js").RawValue>>;
     data: Record<string | symbol, import("../types/data.js").RawValue>[];
 };
+/** keeps only the datum with the smallest x value per group */
 export declare function selectMinX(args: TransformArg<DataRecord>): {
     filter?: import("../types/index.js").ConstantAccessor<boolean, Record<string | symbol, import("../types/data.js").RawValue>>;
     facet?: "auto" | "include" | "exclude" | undefined;
@@ -213,14 +218,14 @@ export declare function selectMinX(args: TransformArg<DataRecord>): {
     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;
+    dodgeX?: DodgeXOptions;
+    dodgeY?: DodgeYOptions;
     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) | {
+    sort?: {
         channel: string;
         order?: "ascending" | "descending";
-    } | import("../types/index.js").ConstantAccessor<import("../types/data.js").RawValue, Record<string | symbol, import("../types/data.js").RawValue>>;
+    } | ((a: import("../types/data.js").RawValue, b: import("../types/data.js").RawValue) => number) | 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>>;
@@ -271,6 +276,7 @@ export declare function selectMinX(args: TransformArg<DataRecord>): {
     cursor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Record<string | symbol, import("../types/data.js").RawValue>>;
     data: Record<string | symbol, import("../types/data.js").RawValue>[];
 };
+/** keeps only the datum with the largest x value per group */
 export declare function selectMaxX(args: TransformArg<DataRecord>): {
     filter?: import("../types/index.js").ConstantAccessor<boolean, Record<string | symbol, import("../types/data.js").RawValue>>;
     facet?: "auto" | "include" | "exclude" | undefined;
@@ -278,14 +284,14 @@ export declare function selectMaxX(args: TransformArg<DataRecord>): {
     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;
+    dodgeX?: DodgeXOptions;
+    dodgeY?: DodgeYOptions;
     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) | {
+    sort?: {
         channel: string;
         order?: "ascending" | "descending";
-    } | import("../types/index.js").ConstantAccessor<import("../types/data.js").RawValue, Record<string | symbol, import("../types/data.js").RawValue>>;
+    } | ((a: import("../types/data.js").RawValue, b: import("../types/data.js").RawValue) => number) | 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>>;
@@ -336,6 +342,7 @@ export declare function selectMaxX(args: TransformArg<DataRecord>): {
     cursor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Record<string | symbol, import("../types/data.js").RawValue>>;
     data: Record<string | symbol, import("../types/data.js").RawValue>[];
 };
+/** keeps only the datum with the smallest y value per group */
 export declare function selectMinY(args: TransformArg<DataRecord>): {
     filter?: import("../types/index.js").ConstantAccessor<boolean, Record<string | symbol, import("../types/data.js").RawValue>>;
     facet?: "auto" | "include" | "exclude" | undefined;
@@ -343,14 +350,14 @@ export declare function selectMinY(args: TransformArg<DataRecord>): {
     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;
+    dodgeX?: DodgeXOptions;
+    dodgeY?: DodgeYOptions;
     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) | {
+    sort?: {
         channel: string;
         order?: "ascending" | "descending";
-    } | import("../types/index.js").ConstantAccessor<import("../types/data.js").RawValue, Record<string | symbol, import("../types/data.js").RawValue>>;
+    } | ((a: import("../types/data.js").RawValue, b: import("../types/data.js").RawValue) => number) | 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>>;
@@ -401,6 +408,7 @@ export declare function selectMinY(args: TransformArg<DataRecord>): {
     cursor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Record<string | symbol, import("../types/data.js").RawValue>>;
     data: Record<string | symbol, import("../types/data.js").RawValue>[];
 };
+/** keeps only the datum with the largest y value per group */
 export declare function selectMaxY(args: TransformArg<DataRecord>): {
     filter?: import("../types/index.js").ConstantAccessor<boolean, Record<string | symbol, import("../types/data.js").RawValue>>;
     facet?: "auto" | "include" | "exclude" | undefined;
@@ -408,14 +416,14 @@ export declare function selectMaxY(args: TransformArg<DataRecord>): {
     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;
+    dodgeX?: DodgeXOptions;
+    dodgeY?: DodgeYOptions;
     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) | {
+    sort?: {
         channel: string;
         order?: "ascending" | "descending";
-    } | import("../types/index.js").ConstantAccessor<import("../types/data.js").RawValue, Record<string | symbol, import("../types/data.js").RawValue>>;
+    } | ((a: import("../types/data.js").RawValue, b: import("../types/data.js").RawValue) => number) | 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>>;

package/dist/transforms/select.js

@@ -1,6 +1,10 @@
 import { groupFacetsAndZ } from '../helpers/group.js';
 import { resolveChannel } from '../helpers/resolve.js';
 // let o: SelectOptions = { x: 'min'};
+/**
+ * selects one datum per group based on the given criteria; use "first"/"last"
+ * for positional selection, or {channel: "min"/"max"} for value-based selection
+ */
 export function select({ data, ...channels }, options) {
     const newData = [];
     groupFacetsAndZ(data, channels, (items) => {
@@ -41,15 +45,19 @@ export function selectFirst(args) {
 export function selectLast(args) {
     return select(args, 'last');
 }
+/** keeps only the datum with the smallest x value per group */
 export function selectMinX(args) {
     return select(args, { x: 'min' });
 }
+/** keeps only the datum with the largest x value per group */
 export function selectMaxX(args) {
     return select(args, { x: 'max' });
 }
+/** keeps only the datum with the smallest y value per group */
 export function selectMinY(args) {
     return select(args, { y: 'min' });
 }
+/** keeps only the datum with the largest y value per group */
 export function selectMaxY(args) {
     return select(args, { y: 'max' });
 }

package/dist/transforms/shift.d.ts

@@ -2,12 +2,20 @@ import type { DataRecord, TransformArg } from '../types/index.js';
 type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
     [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
 }[Keys];
+/** per-channel shift amounts for x channels; values can be numbers or time interval strings (e.g. "1 month") */
 type ShiftXOptions = {
     [key in 'x' | 'x1' | 'x2']: string | number;
 };
+/**
+ * shifts the x channel values by a fixed amount or time interval
+ */
 export declare function shiftX({ data, ...channels }: TransformArg<DataRecord>, shiftBy: string | number | RequireAtLeastOne<ShiftXOptions>): TransformArg<DataRecord>;
+/** per-channel shift amounts for y channels; values can be numbers or time interval strings (e.g. "1 month") */
 type ShiftYOptions = {
     [key in 'y' | 'y1' | 'y2']: string | number;
 };
+/**
+ * shifts the y channel values by a fixed amount or time interval
+ */
 export declare function shiftY({ data, ...channels }: TransformArg<DataRecord>, shiftBy: string | number | RequireAtLeastOne<ShiftYOptions>): TransformArg<DataRecord>;
 export {};

package/dist/transforms/shift.js

@@ -1,5 +1,8 @@
 import { resolveChannel } from '../helpers/resolve.js';
 import { maybeTimeInterval } from '../helpers/time.js';
+/**
+ * shifts the x channel values by a fixed amount or time interval
+ */
 export function shiftX({ data, ...channels }, shiftBy) {
     if (typeof shiftBy === 'number' || typeof shiftBy === 'string') {
         shiftBy = { x: shiftBy };
@@ -10,6 +13,9 @@ export function shiftX({ data, ...channels }, shiftBy) {
     }
     return { data, ...channels };
 }
+/**
+ * shifts the y channel values by a fixed amount or time interval
+ */
 export function shiftY({ data, ...channels }, shiftBy) {
     if (typeof shiftBy === 'number' || typeof shiftBy === 'string') {
         shiftBy = { y: shiftBy };