svelteplot 0.10.3 → 0.11.0

package/dist/transforms/normalize.d.ts

@@ -1,5 +1,4 @@
 import type { TransformArg, RawValue, MapIndexObject } from '../types/index.js';
-import { sort } from './sort.js';
 type BasisFunction = (I: number[], S: RawValue[]) => number;
 type NormalizeBasis = 'deviation' | 'first' | 'last' | 'min' | 'max' | 'mean' | 'median' | 'sum' | 'extent' | BasisFunction | MapIndexObject;
 type NormalizeOptions = NormalizeBasis | {
@@ -8,11 +7,283 @@ type NormalizeOptions = NormalizeBasis | {
 /**
  * Normalizes the x values based on the specified basis. Uses mapX.
  */
-export declare function normalizeX<T>(args: TransformArg<T>, options: NormalizeOptions): any;
+export declare function normalizeX<T>(args: TransformArg<T>, options: NormalizeOptions): {
+    filter?: import("../types/index.js").ConstantAccessor<boolean, T>;
+    facet?: "auto" | "include" | "exclude" | undefined;
+    fx?: import("../types/channel.js").ChannelAccessor<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;
+    fill?: import("../types/channel.js").ChannelAccessor<T>;
+    fillOpacity?: import("../types/index.js").ConstantAccessor<number, T>;
+    fontFamily?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontFamily, T>;
+    fontSize?: import("../types/index.js").ConstantAccessor<number | "-moz-initial" | "inherit" | "initial" | "revert" | "revert-layer" | "unset" | "math" | (string & {}) | "large" | "medium" | "small" | "x-large" | "x-small" | "xx-large" | "xx-small" | "xxx-large" | "larger" | "smaller", T>;
+    fontStyle?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontStyle, T>;
+    fontVariant?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontVariant, T>;
+    fontWeight?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontWeight, T>;
+    letterSpacing?: import("../types/index.js").ConstantAccessor<import("csstype").Property.LetterSpacing<0 | (string & {})>, T>;
+    wordSpacing?: import("../types/index.js").ConstantAccessor<import("csstype").Property.WordSpacing<0 | (string & {})>, T>;
+    textAnchor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.TextAnchor, T>;
+    textTransform?: import("../types/index.js").ConstantAccessor<import("csstype").Property.TextTransform, T>;
+    textDecoration?: import("../types/index.js").ConstantAccessor<import("csstype").Property.TextDecoration<0 | (string & {})>, T>;
+    sort?: ((a: RawValue, b: RawValue) => number) | {
+        channel: string;
+        order?: "ascending" | "descending";
+    } | import("../types/index.js").ConstantAccessor<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>;
+    strokeLinejoin?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, T>;
+    strokeLinecap?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, T>;
+    strokeMiterlimit?: import("../types/index.js").ConstantAccessor<number, T>;
+    opacity?: import("../types/channel.js").ChannelAccessor<T>;
+    strokeDasharray?: import("../types/index.js").ConstantAccessor<string, T>;
+    strokeDashoffset?: import("../types/index.js").ConstantAccessor<number, T>;
+    blend?: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, T>;
+    mixBlendMode?: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, T>;
+    clipPath?: string | undefined;
+    mask?: string | undefined;
+    imageFilter?: import("../types/index.js").ConstantAccessor<string, T>;
+    shapeRendering?: import("../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, T>;
+    paintOrder?: import("../types/index.js").ConstantAccessor<string, T>;
+    onclick?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ondblclick?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onmouseup?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onmousedown?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onmouseenter?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onmousemove?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onmouseleave?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onmouseout?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onmouseover?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onpointercancel?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onpointerdown?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onpointerup?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onpointerenter?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onpointerleave?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onpointermove?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onpointerover?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onpointerout?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ondrag?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ondrop?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ondragstart?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ondragenter?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ondragleave?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ondragover?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ondragend?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ontouchstart?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ontouchmove?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ontouchend?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ontouchcancel?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    oncontextmenu?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onwheel?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    class?: string | undefined;
+    style?: string | undefined;
+    cursor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, T>;
+    title?: import("../types/index.js").ConstantAccessor<string, T>;
+    data: Record<string | symbol, RawValue>[];
+};
 /**
  * Normalizes the y values based on the specified basis. Uses mapY.
  */
-export declare function normalizeY<T>(args: TransformArg<T>, options: NormalizeOptions): any;
+export declare function normalizeY<T>(args: TransformArg<T>, options: NormalizeOptions): {
+    filter?: import("../types/index.js").ConstantAccessor<boolean, T>;
+    facet?: "auto" | "include" | "exclude" | undefined;
+    fx?: import("../types/channel.js").ChannelAccessor<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;
+    fill?: import("../types/channel.js").ChannelAccessor<T>;
+    fillOpacity?: import("../types/index.js").ConstantAccessor<number, T>;
+    fontFamily?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontFamily, T>;
+    fontSize?: import("../types/index.js").ConstantAccessor<number | "-moz-initial" | "inherit" | "initial" | "revert" | "revert-layer" | "unset" | "math" | (string & {}) | "large" | "medium" | "small" | "x-large" | "x-small" | "xx-large" | "xx-small" | "xxx-large" | "larger" | "smaller", T>;
+    fontStyle?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontStyle, T>;
+    fontVariant?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontVariant, T>;
+    fontWeight?: import("../types/index.js").ConstantAccessor<import("csstype").Property.FontWeight, T>;
+    letterSpacing?: import("../types/index.js").ConstantAccessor<import("csstype").Property.LetterSpacing<0 | (string & {})>, T>;
+    wordSpacing?: import("../types/index.js").ConstantAccessor<import("csstype").Property.WordSpacing<0 | (string & {})>, T>;
+    textAnchor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.TextAnchor, T>;
+    textTransform?: import("../types/index.js").ConstantAccessor<import("csstype").Property.TextTransform, T>;
+    textDecoration?: import("../types/index.js").ConstantAccessor<import("csstype").Property.TextDecoration<0 | (string & {})>, T>;
+    sort?: ((a: RawValue, b: RawValue) => number) | {
+        channel: string;
+        order?: "ascending" | "descending";
+    } | import("../types/index.js").ConstantAccessor<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>;
+    strokeLinejoin?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, T>;
+    strokeLinecap?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, T>;
+    strokeMiterlimit?: import("../types/index.js").ConstantAccessor<number, T>;
+    opacity?: import("../types/channel.js").ChannelAccessor<T>;
+    strokeDasharray?: import("../types/index.js").ConstantAccessor<string, T>;
+    strokeDashoffset?: import("../types/index.js").ConstantAccessor<number, T>;
+    blend?: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, T>;
+    mixBlendMode?: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, T>;
+    clipPath?: string | undefined;
+    mask?: string | undefined;
+    imageFilter?: import("../types/index.js").ConstantAccessor<string, T>;
+    shapeRendering?: import("../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, T>;
+    paintOrder?: import("../types/index.js").ConstantAccessor<string, T>;
+    onclick?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ondblclick?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onmouseup?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onmousedown?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onmouseenter?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onmousemove?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onmouseleave?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onmouseout?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onmouseover?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onpointercancel?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onpointerdown?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onpointerup?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onpointerenter?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onpointerleave?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onpointermove?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onpointerover?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onpointerout?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ondrag?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ondrop?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ondragstart?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ondragenter?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ondragleave?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ondragover?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ondragend?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ontouchstart?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ontouchmove?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ontouchend?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    ontouchcancel?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    oncontextmenu?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    onwheel?: ((event: Event & {
+        currentTarget: SVGPathElement;
+    }, datum: T, index: number) => void) | undefined;
+    class?: string | undefined;
+    style?: string | undefined;
+    cursor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, T>;
+    title?: import("../types/index.js").ConstantAccessor<string, T>;
+    data: Record<string | symbol, RawValue>[];
+};
 /**
  * Convenience wrapper for normalizeY for parallel coordinates.
  *
@@ -21,7 +292,7 @@ export declare function normalizeY<T>(args: TransformArg<T>, options: NormalizeO
  * - y: the value to normalize (e.g., 'Value')
  * - z: the grouping variable (e.g., 'Id')
  */
-export declare function normalizeParallelY<T>(args: TransformArg<T>, basis: NormalizeBasis): ReturnType<typeof sort<T>>;
+export declare function normalizeParallelY<T>(args: TransformArg<T>, basis: NormalizeBasis): TransformArg<T>;
 /**
  * Convenience wrapper for normalizeY for parallel coordinates.
  *
@@ -30,5 +301,5 @@ export declare function normalizeParallelY<T>(args: TransformArg<T>, basis: Norm
  * - y: the value to normalize (e.g., 'Value')
  * - z: the grouping variable (e.g., 'Id')
  */
-export declare function normalizeParallelX<T>(args: TransformArg<T>, basis: NormalizeBasis): ReturnType<typeof sort<T>>;
+export declare function normalizeParallelX<T>(args: TransformArg<T>, basis: NormalizeBasis): TransformArg<T>;
 export {};

package/dist/transforms/normalize.js

@@ -65,9 +65,9 @@ function normalizeAccessor(f) {
 const normalizeExtent = {
     mapIndex(I, S, T) {
         const [s1, s2] = extent(I, (i) => S[i]);
-        const d = s2 - s1;
+        const d = (s2 ?? 0) - (s1 ?? 0);
         for (const i of I) {
-            T[i] = S[i] === null ? NaN : (S[i] - s1) / d;
+            T[i] = S[i] === null ? NaN : (S[i] - (s1 ?? 0)) / d;
         }
     }
 };
@@ -77,6 +77,7 @@ const normalizeFirst = normalizeBasis((I, S) => {
         if (s != null && isFinite(s))
             return s;
     }
+    return NaN;
 });
 const normalizeLast = normalizeBasis((I, S) => {
     for (let i = I.length - 1; i >= 0; --i) {
@@ -84,13 +85,14 @@ const normalizeLast = normalizeBasis((I, S) => {
         if (s != null && isFinite(s))
             return s;
     }
+    return NaN;
 });
 const normalizeDeviation = {
     mapIndex(I, S, T) {
         const m = mean(I, (i) => S[i]);
         const d = deviation(I, (i) => S[i]);
         for (const i of I) {
-            T[i] = S[i] === null ? NaN : d ? (S[i] - m) / d : 0;
+            T[i] = S[i] === null ? NaN : d ? (S[i] - (m ?? 0)) / d : 0;
         }
     }
 };

package/dist/transforms/recordize.d.ts

@@ -1,15 +1,23 @@
 import type { TransformArgsRow, TransformArgsRecord, DataRecord, DataRow } from '../types/index.js';
-import { INDEX } from '../constants';
+import { INDEX } from '../constants.js';
 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 function recordizeX<T>({ data, ...channels }: TransformArgsRow<DataRow>, { withIndex }?: {
+/**
+ * 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({ data, ...channels }: TransformArgsRow<DataRow>, { withIndex }?: {
     withIndex: boolean;
 }): TransformArgsRecord<DataRecord>;
-export declare function recordizeY<T>({ data, ...channels }: TransformArgsRow<DataRow>, { withIndex }?: {
+/**
+ * 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({ data, ...channels }: TransformArgsRow<DataRow>, { withIndex }?: {
     withIndex: boolean;
 }): TransformArgsRecord<DataRecord>;
 /**
@@ -17,5 +25,9 @@ export declare function recordizeY<T>({ data, ...channels }: TransformArgsRow<Da
  * as dataset to marks that support it. It transforms the arrays into records, so
  * 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>;
-export declare function recordize<T>({ data, ...channels }: TransformArgsRow<T>): TransformArgsRecord<T>;
+export declare function recordizeXY({ data, ...channels }: TransformArgsRow<DataRow>): TransformArgsRecord<DataRecord>;
+/**
+ * wraps raw values into data records with index tracking, without
+ * assigning them to a specific positional channel
+ */
+export declare function recordize({ data, ...channels }: TransformArgsRow<DataRow>): TransformArgsRecord<DataRecord>;

package/dist/transforms/recordize.js

@@ -1,21 +1,21 @@
 import isDataRecord from '../helpers/isDataRecord.js';
-import { INDEX } from '../constants';
+import { INDEX } from '../constants.js';
 export const X = Symbol('x');
 export const Y = Symbol('y');
 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;
     if (dataIsRawValueArray) {
         // we remove x, x1 and x2 from the channels since they make no sense when
         // the data is a raw value array
-        const { x, x1, x2, ...nonXChannels } = channels;
+        const { x: _x, x1: _x1, x2: _x2, ...nonXChannels } = channels;
         return {
             data: data.map((value, index) => ({
                 [RAW_VALUE]: value,
@@ -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)
@@ -39,7 +39,7 @@ export function recordizeY({ data, ...channels }, { withIndex } = { withIndex: t
     if (dataIsRawValueArray) {
         // we remove y, y1 and y2 from the channels since they make no sense when
         // the data is a raw value array
-        const { y, y1, y2, ...nonYChannels } = channels;
+        const { y: _y, y1: _y1, y2: _y2, ...nonYChannels } = channels;
         return {
             data: Array.from(data).map((value, index) => ({
                 [INDEX]: index,
@@ -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

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

package/dist/transforms/rename.js

@@ -23,16 +23,21 @@ export function renameChannelsAndData({ data, ...channels }, options) {
     const newData = [];
     for (const datum of data) {
         const newDatum = { ...datum };
+        const mutableDatum = newDatum;
         for (const [from, to] of Object.entries(options)) {
             if (channels[from] !== undefined) {
-                newDatum[to] = newDatum[from];
-                delete newDatum[from];
+                mutableDatum[to] = mutableDatum[from];
+                delete mutableDatum[from];
             }
         }
         newData.push(newDatum);
     }
     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)) {