svelteplot 0.4.2-pr-193.0 → 0.4.2-pr-194.0

package/dist/Mark.svelte

@@ -135,11 +135,12 @@
     const resolvedData: ResolvedDataRecord<Datum>[] = $derived(
         data
             .map((d, i) => ({ ...d, [INDEX]: i }))
-            .flatMap((row) => {
+            .flatMap((row, index) => {
                 const channels = options as Record<ChannelName, ChannelAccessor<Datum>>;
                 if (!testFacet(row, channels) || !testFilter(row, channels)) return [];
                 const out: ResolvedDataRecord<Datum> = {
-                    datum: row
+                    datum: row,
+                    index
                 };
                 for (const [channel] of Object.entries(CHANNEL_SCALE) as [
                     ScaledChannelName,
@@ -208,6 +209,7 @@
         resolvedData.flatMap((row) => {
             const out: ScaledDataRecord<Datum> = {
                 datum: row.datum,
+                index: row[INDEX],
                 valid: true
             };
             // compute dx/dy

package/dist/helpers/resolve.js

@@ -1,4 +1,4 @@
-import { CHANNEL_SCALE } from '../constants.js';
+import { CHANNEL_SCALE, INDEX } from '../constants.js';
 import isDataRecord from './isDataRecord.js';
 import isRawValue from './isRawValue.js';
 import { isValid } from './index.js';
@@ -11,7 +11,7 @@ export function resolveProp(accessor, datum, _defaultValue = null) {
         // so we're passing the original value to accessor functions instead of our wrapped record
         return datum == null
             ? accessor()
-            : accessor(datum[RAW_VALUE] != null ? datum[RAW_VALUE] : datum);
+            : accessor(datum[RAW_VALUE] != null ? datum[RAW_VALUE] : datum, datum[INDEX]);
     }
     else if ((typeof accessor === 'string' || typeof accessor === 'symbol') &&
         datum &&
@@ -51,7 +51,7 @@ function resolve(datum, accessor, channel, scale) {
             // datum[RAW_VALUE] exists if an array of raw values was used as dataset and got
             // "recordized" by the recordize transform. We want to hide this wrapping to the user
             // so we're passing the original value to accessor functions instead of our wrapped record
-            return accessor(datum[RAW_VALUE] != null ? datum[RAW_VALUE] : datum);
+            return accessor(datum[RAW_VALUE] != null ? datum[RAW_VALUE] : datum, datum?.[INDEX]);
         // use accessor string
         if ((typeof accessor === 'string' || typeof accessor === 'symbol') &&
             datum[accessor] !== undefined)
@@ -69,7 +69,7 @@ function resolve(datum, accessor, channel, scale) {
     else {
         // return single value or accessor
         return typeof accessor === 'function'
-            ? accessor(datum)
+            ? accessor(datum, datum?.[INDEX])
             : accessor !== null && isRawValue(accessor)
                 ? accessor
                 : !Array.isArray(datum) && (scale === 'x' || scale === 'y')

package/dist/marks/RuleX.svelte

@@ -3,7 +3,7 @@
 -->
 <script lang="ts" generics="Datum = DataRecord | RawValue">
     interface RuleXMarkProps extends Omit<BaseMarkProps<Datum>, 'fill' | 'fillOpacity'> {
-        data: Datum[];
+        data?: Datum[];
         x?: ChannelAccessor<Datum>;
         y1?: ChannelAccessor<Datum>;
         y2?: ChannelAccessor<Datum>;

package/dist/marks/RuleX.svelte.d.ts

@@ -60,7 +60,7 @@ declare class __sveltets_Render<Datum = DataRecord | RawValue> {
         class: string | null;
         cursor: ConstantAccessor<import("csstype").Property.Cursor, Datum>;
     }>, "fill" | "fillOpacity"> & {
-        data: Datum[];
+        data?: Datum[] | undefined;
         x?: ChannelAccessor<Datum>;
         y1?: ChannelAccessor<Datum>;
         y2?: ChannelAccessor<Datum>;

package/dist/transforms/recordize.d.ts

@@ -1,16 +1,18 @@
 import type { TransformArgsRow, TransformArgsRecord } from '../types/index.js';
-export declare const INDEX: unique symbol;
+export declare const X: unique symbol;
+export declare const Y: unique symbol;
 export declare const RAW_VALUE: unique symbol;
-export declare function recordizeX({ data, ...channels }: TransformArgsRow, { withIndex }?: {
+export declare function indexData<T extends object>(data: T[]): (T & {})[];
+export declare function recordizeX<T>({ data, ...channels }: TransformArgsRow<T>, { withIndex }?: {
     withIndex: boolean;
-}): TransformArgsRecord;
-export declare function recordizeY({ data, ...channels }: TransformArgsRow, { withIndex }?: {
+}): TransformArgsRecord<T>;
+export declare function recordizeY<T>({ data, ...channels }: TransformArgsRow<T>, { withIndex }?: {
     withIndex: boolean;
-}): TransformArgsRecord;
+}): TransformArgsRecord<T>;
 /**
  * This transform is used to allow users to pass an [[x0, y0], [x1, y1], ...] array
  * 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({ data, ...channels }: TransformArgsRow): TransformArgsRecord;
-export declare function recordize({ data, ...channels }: TransformArgsRow): TransformArgsRecord;
+export declare function recordizeXY<T>({ data, ...channels }: TransformArgsRow<T>): TransformArgsRecord<T>;
+export declare function recordize<T>({ data, ...channels }: TransformArgsRow<T>): TransformArgsRecord<T>;

package/dist/transforms/recordize.js

@@ -1,6 +1,11 @@
 import isDataRecord from '../helpers/isDataRecord.js';
-export const INDEX = Symbol('index');
+import { INDEX } from '../constants';
+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
@@ -10,16 +15,15 @@ export function recordizeX({ data, ...channels }, { withIndex } = { withIndex: t
     if (dataIsRawValueArray) {
         return {
             data: data.map((value, index) => ({
-                __value: value,
-                ...(withIndex ? { [INDEX]: index } : {}),
-                [RAW_VALUE]: value
+                [RAW_VALUE]: value,
+                [INDEX]: index
             })),
             ...channels,
             x: RAW_VALUE,
             ...(withIndex ? { y: INDEX } : {})
         };
     }
-    return { data: data, ...channels };
+    return { data: indexData(data), ...channels };
 }
 /*
  * This transform takes an array of raw values as input and returns data records
@@ -32,22 +36,15 @@ export function recordizeY({ data, ...channels }, { withIndex } = { withIndex: t
     if (dataIsRawValueArray) {
         return {
             data: Array.from(data).map((value, index) => ({
-                ...(withIndex ? { __index: index } : {}),
+                [INDEX]: index,
                 [RAW_VALUE]: value
             })),
             ...channels,
-            ...(withIndex ? { x: '__index' } : {}),
+            ...(withIndex ? { x: INDEX } : {}),
             y: RAW_VALUE
         };
     }
-    return {
-        data: Array.from(data).map((d, index) => ({
-            ...d,
-            ...(withIndex ? { __index: index } : {})
-        })),
-        x: '__index',
-        ...channels
-    };
+    return { data: indexData(data), ...channels };
 }
 /**
  * This transform is used to allow users to pass an [[x0, y0], [x1, y1], ...] array
@@ -62,28 +59,30 @@ export function recordizeXY({ data, ...channels }) {
         channels.x === undefined &&
         channels.y === undefined) {
         return {
-            data: data.map(([x, y, ...rest]) => ({
+            data: data.map(([x, y, ...rest], i) => ({
                 [RAW_VALUE]: [x, y, ...rest],
-                __x: x,
-                __y: y
+                [INDEX]: i,
+                [X]: x,
+                [Y]: y
             })),
             ...channels,
-            x: '__x',
-            y: '__y'
+            x: X,
+            y: Y
         };
     }
-    return { data, ...channels };
+    return { data: data, ...channels };
 }
 export function recordize({ data, ...channels }) {
     if (!data)
         return { data, ...channels };
     if (!isDataRecord(data[0])) {
         return {
-            data: data.map((d) => ({
-                [RAW_VALUE]: d
+            data: data.map((d, i) => ({
+                [RAW_VALUE]: d,
+                [INDEX]: i
             })),
             ...channels
         };
     }
-    return { data, ...channels };
+    return { data: indexData(data), ...channels };
 }

package/dist/types/channel.d.ts

@@ -6,7 +6,7 @@ export type ChannelAccessor<T = Record<string | symbol, RawValue>> = ChannelValu
     /** you can bypass the scale by passing null */
     scale: boolean | null;
 };
-export type ChannelValue<T = Record<string | symbol, RawValue>> = RawValue | keyof T | ((d: T) => RawValue) | null | undefined;
+export type ChannelValue<T = Record<string | symbol, RawValue>> = RawValue | keyof T | ((d: T, index: number) => RawValue) | null | undefined;
 export type ScaledChannelName = 'fill' | 'fillOpacity' | 'opacity' | 'r' | 'length' | 'stroke' | 'strokeOpacity' | 'symbol' | 'fx' | 'fy' | 'x' | 'x1' | 'x2' | 'y' | 'y1' | 'y2';
 export type ScaledChannelType<T extends ScaledChannelName> = T extends 'fill' | 'stroke' | 'symbol' ? string : number;
 export type ChannelName = ScaledChannelName | 'z' | 'sort' | 'filter' | 'interval';

package/dist/types/data.d.ts

@@ -3,6 +3,7 @@ export type RawValue = number | Date | boolean | string | symbol;
 export type DataRecord<T = Record<string | symbol, RawValue>> = T;
 export type ResolvedDataRecord<T = Record<string | symbol, RawValue>> = Partial<Record<ScaledChannelName, any>> & {
     datum: DataRecord<T>;
+    index: number;
 };
 export type ScaledDataRecord<T = Record<string | symbol, RawValue>> = Partial<{
     [K in ScaledChannelName]?: ScaledChannelType<K>;
@@ -11,5 +12,6 @@ export type ScaledDataRecord<T = Record<string | symbol, RawValue>> = Partial<{
     dy: number;
     datum: DataRecord<T>;
     valid: Boolean;
+    index: number;
 };
 export type DataRow<T = Record<string | symbol, RawValue>> = DataRecord<T> | RawValue | [number, number] | null;

package/dist/types/index.d.ts

@@ -2,7 +2,7 @@ import type { Snippet } from 'svelte';
 import type { Writable } from 'svelte/store';
 import type { MarkerShape } from '../marks/helpers/Marker.svelte';
 import type { Channels, ScaledChannelName } from './channel.js';
-import type { DataRecord, DataRow, RawValue } from './data.js';
+import type { RawValue } from './data.js';
 import type { BaseMarkProps } from './mark.js';
 export type GenericMarkOptions = Record<string | symbol, any>;
 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';
@@ -24,18 +24,18 @@ export type MarkerOptions = {
      */
     marker?: boolean | MarkerShape | Snippet;
 };
-export type ConstantAccessor<K, T = Record<string | symbol, RawValue>> = K | ((d: T) => K) | null | undefined;
+export type ConstantAccessor<K, T = Record<string | symbol, RawValue>> = K | ((d: T, index: number) => K) | null | undefined;
 export type TransformArg<T> = Channels<T> & BaseMarkProps<T> & {
     data: T[];
 };
 export type MapArg<T> = Channels<T> & {
     data: T[];
 };
-export type TransformArgsRow = Partial<Channels> & {
-    data: DataRow[];
+export type TransformArgsRow<T extends RawValue & object> = Partial<Channels<T>> & {
+    data: T[];
 };
-export type TransformArgsRecord = Partial<Channels> & {
-    data: DataRecord[];
+export type TransformArgsRecord<T extends object> = Partial<Channels<T>> & {
+    data: T[];
 };
 export type AutoMarginStores = {
     autoMarginTop: Writable<Map<string, number>>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "svelteplot",
-    "version": "0.4.2-pr-193.0",
+    "version": "0.4.2-pr-194.0",
     "license": "ISC",
     "author": {
         "name": "Gregor Aisch",