svelteplot 0.4.5-pr-208.4 → 0.4.5

package/dist/Mark.svelte

@@ -41,7 +41,6 @@
     import { testFilter, isValid } from './helpers/index.js';
     import { resolveChannel, resolveProp } from './helpers/resolve.js';
     import { RENAME } from './transforms/rename.js';
-    import { dodgeX, dodgeY } from './transforms/dodge.js';
 
     let {
         data = [],
@@ -208,98 +207,85 @@
      * elements to the scales
      */
     const scaledData = $derived(
-        dodge(
-            resolvedData.flatMap((row) => {
-                const out: ScaledDataRecord<Datum> = {
-                    datum: row.datum,
-                    index: row[INDEX],
-                    valid: true
-                };
-                // compute dx/dy
-                out.dx = Number(resolveProp<number>(options.dx, out.datum, 0));
-                out.dy = Number(resolveProp<number>(options.dy, out.datum, 0));
-
-                // special handling if there's a projection, e.g. a line mark
-                if (plot.scales.projection && mark.type !== 'geo') {
-                    for (const suffix of ['', '1', '2']) {
-                        if (
-                            options?.[`x${suffix}`] !== undefined &&
-                            options?.[`y${suffix}`] !== undefined
-                        ) {
-                            // we have two-dimensional accessors
-                            // for the x and y channels
-                            const [x, y] =
-                                mark.type === 'line'
-                                    ? [row.x, row.y] // line paths are projected later
-                                    : projectXY(
-                                          plot.scales,
-                                          row.x,
-                                          row.y,
-                                          usedScales.x,
-                                          usedScales.y,
-                                          suffix
-                                      );
-
-                            out[`x${suffix}`] = x;
-                            out[`y${suffix}`] = y;
-                            out.valid =
-                                out.valid &&
-                                isValid(row.x) &&
-                                isValid(row.y) &&
-                                isValid(x) &&
-                                isValid(y);
-                        }
+        resolvedData.flatMap((row) => {
+            const out: ScaledDataRecord<Datum> = {
+                datum: row.datum,
+                index: row[INDEX],
+                valid: true
+            };
+            // compute dx/dy
+            out.dx = Number(resolveProp<number>(options.dx, out.datum, 0));
+            out.dy = Number(resolveProp<number>(options.dy, out.datum, 0));
+
+            // special handling if there's a projection, e.g. a line mark
+            if (plot.scales.projection && mark.type !== 'geo') {
+                for (const suffix of ['', '1', '2']) {
+                    if (
+                        options?.[`x${suffix}`] !== undefined &&
+                        options?.[`y${suffix}`] !== undefined
+                    ) {
+                        // we have two-dimensional accessors
+                        // for the x and y channels
+                        const [x, y] =
+                            mark.type === 'line'
+                                ? [row.x, row.y] // line paths are projected later
+                                : projectXY(
+                                      plot.scales,
+                                      row.x,
+                                      row.y,
+                                      usedScales.x,
+                                      usedScales.y,
+                                      suffix
+                                  );
+
+                        out[`x${suffix}`] = x;
+                        out[`y${suffix}`] = y;
+                        out.valid =
+                            out.valid &&
+                            isValid(row.x) &&
+                            isValid(row.y) &&
+                            isValid(x) &&
+                            isValid(y);
                     }
                 }
+            }
 
-                // iterate over all scaled channels
-                for (const [channel, scale] of Object.entries(CHANNEL_SCALE) as [
-                    ScaledChannelName,
-                    ScaleName
-                ][]) {
-                    // check if the mark has defined an accessor for this channel
-                    if (options?.[channel] != null && out[channel] === undefined) {
-                        // resolve value
-                        const value = row[channel];
-                        // if this channel was renamed, use the original channel for scaling
-                        const origChannel = options?.[RENAME]?.[channel] || channel;
-                        const scaled = usedScales[channel]
-                            ? scale === 'x'
-                                ? projectX(origChannel as 'x' | 'x1' | 'x2', plot.scales, value)
-                                : scale === 'y'
-                                  ? projectY(origChannel as 'y' | 'y1' | 'y2', plot.scales, value)
-                                  : scale === 'color' && !isValid(value)
-                                    ? plot.options.color.unknown
-                                    : plot.scales[scale].fn(value)
-                            : value;
-
-                        out.valid = out.valid && (scale === 'color' || isValid(value));
-
-                        // apply dx/dy transform
-                        out[channel] =
-                            Number.isFinite(scaled) && (scale === 'x' || scale === 'y')
-                                ? scaled + (scale === 'x' ? out.dx : out.dy)
-                                : scaled;
-                    } else if (defaults[channel]) {
-                        out[channel] = defaults[channel];
-                    }
+            // iterate over all scaled channels
+            for (const [channel, scale] of Object.entries(CHANNEL_SCALE) as [
+                ScaledChannelName,
+                ScaleName
+            ][]) {
+                // check if the mark has defined an accessor for this channel
+                if (options?.[channel] != null && out[channel] === undefined) {
+                    // resolve value
+                    const value = row[channel];
+                    // if this channel was renamed, use the original channel for scaling
+                    const origChannel = options?.[RENAME]?.[channel] || channel;
+                    const scaled = usedScales[channel]
+                        ? scale === 'x'
+                            ? projectX(origChannel as 'x' | 'x1' | 'x2', plot.scales, value)
+                            : scale === 'y'
+                              ? projectY(origChannel as 'y' | 'y1' | 'y2', plot.scales, value)
+                              : scale === 'color' && !isValid(value)
+                                ? plot.options.color.unknown
+                                : plot.scales[scale].fn(value)
+                        : value;
+
+                    out.valid = out.valid && (scale === 'color' || isValid(value));
+
+                    // apply dx/dy transform
+                    out[channel] =
+                        Number.isFinite(scaled) && (scale === 'x' || scale === 'y')
+                            ? scaled + (scale === 'x' ? out.dx : out.dy)
+                            : scaled;
+                } else if (defaults[channel]) {
+                    out[channel] = defaults[channel];
                 }
+            }
 
-                return [out];
-            }),
-            options
-        )
+            return [out];
+        })
     );
-
-    function dodge<T>(data: ScaledDataRecord<Datum>[], options: BaseMarkProps<T>) {
-        if (options.dodgeX) {
-            return dodgeX({ data, ...options }, plot);
-        }
-        if (options.dodgeY) {
-            return dodgeY({ data, ...options }, plot);
-        }
-        return data;
-    }
 </script>
 
 {#if errors.length}

package/dist/Mark.svelte.d.ts

@@ -1,17 +1,14 @@
 import { type Snippet } from 'svelte';
-import { CHANNEL_SCALE } from './constants.js';
 import type { ScaledChannelName, MarkType, DataRecord, ChannelAccessor, ScaleName, RawValue, ScaledDataRecord, ScaleType } from './types/index.js';
 import { getUsedScales } from './helpers/scales.js';
 declare class __sveltets_Render<Datum extends DataRecord> {
     props(): Partial<Partial<{
-        filter: import("./types/index.js").ConstantAccessor<boolean, Datum>;
-        facet: "auto" | "include" | "exclude";
+        filter?: import("./types/index.js").ConstantAccessor<boolean, Datum>;
+        facet?: "auto" | "include" | "exclude";
         fx: ChannelAccessor<Datum>;
         fy: ChannelAccessor<Datum>;
         dx: import("./types/index.js").ConstantAccessor<number, Datum>;
         dy: import("./types/index.js").ConstantAccessor<number, Datum>;
-        dodgeX: CHANNEL_SCALE;
-        dodgeY: CHANNEL_SCALE;
         fill: ChannelAccessor<Datum>;
         fillOpacity: import("./types/index.js").ConstantAccessor<number, Datum>;
         sort: {
@@ -32,38 +29,38 @@ declare class __sveltets_Render<Datum extends DataRecord> {
         imageFilter: import("./types/index.js").ConstantAccessor<string, Datum>;
         shapeRendering: import("./types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, Datum>;
         paintOrder: import("./types/index.js").ConstantAccessor<string, Datum>;
-        onclick: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        ondblclick: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        onmouseup: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        onmousedown: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        onmouseenter: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        onmousemove: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        onmouseleave: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        onmouseout: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        onmouseover: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        onpointercancel: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        onpointerdown: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        onpointerup: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        onpointerenter: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        onpointerleave: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        onpointermove: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        onpointerover: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        onpointerout: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        ondrag: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        ondrop: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        ondragstart: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        ondragenter: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        ondragleave: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        ondragover: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        ondragend: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        ontouchstart: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        ontouchmove: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        ontouchend: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        ontouchcancel: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        oncontextmenu: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        onwheel: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-        class: string;
-        style: string;
+        onclick?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ondblclick?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onmouseup?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onmousedown?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onmouseenter?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onmousemove?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onmouseleave?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onmouseout?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onmouseover?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onpointercancel?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onpointerdown?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onpointerup?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onpointerenter?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onpointerleave?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onpointermove?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onpointerover?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onpointerout?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ondrag?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ondrop?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ondragstart?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ondragenter?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ondragleave?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ondragover?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ondragend?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ontouchstart?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ontouchmove?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ontouchend?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        ontouchcancel?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        oncontextmenu?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        onwheel?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
+        class?: string;
+        style?: string;
         cursor: import("./types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Datum>;
     }>> & {
         data?: Datum[] | undefined;

package/dist/helpers/colors.d.ts

@@ -6,7 +6,7 @@ type SchemeGetter = (n: number) => readonly string[];
 export declare function isOrdinalScheme(scheme: ColorScheme): boolean;
 export declare function ordinalScheme(scheme: string): SchemeGetter | undefined;
 export declare function ordinalRange(scheme: string, length: number): readonly string[] | undefined;
-export declare function maybeBooleanRange(domain: boolean[], scheme?: string): any[] | undefined;
+export declare function maybeBooleanRange(domain: boolean[], scheme?: string): unknown[] | undefined;
 export declare function isQuantitativeScheme(scheme: string): boolean;
 export declare function quantitativeScheme(scheme: string): typeof interpolateBrBG | undefined;
 export declare function isDivergingScheme(scheme: string): boolean;

package/dist/helpers/index.d.ts

@@ -3,8 +3,8 @@ import type { Snippet } from 'svelte';
 /**
  * Returns first argument that is not null or undefined
  */
-export declare function coalesce(...args: (RawValue | undefined | null)[]): any;
-export declare function testFilter<T>(datum: T, options: Channels<T>): any;
+export declare function coalesce(...args: (RawValue | undefined | null)[]): RawValue | null;
+export declare function testFilter<T>(datum: T, options: Channels<T>): true | T | null;
 export declare function randomId(): string;
 export declare function isSnippet(value: unknown): value is Snippet;
 export declare function isValid(value: RawValue | undefined): value is number | Date | string;

package/dist/helpers/scales.d.ts

@@ -15,7 +15,7 @@ export declare function createScale<T extends ScaleOptions>(name: ScaleName, sca
     autoTitle?: undefined;
 } | {
     type: ScaleType;
-    domain: any;
+    domain: RawValue[] | [undefined, undefined];
     range: any;
     fn: any;
     skip: Map<ScaledChannelName, Set<symbol>>;
@@ -28,7 +28,7 @@ export declare function createScale<T extends ScaleOptions>(name: ScaleName, sca
  * Infer a scale type based on the scale name, the data values mapped to it and
  * the mark types that are bound to the scale
  */
-export declare function inferScaleType(name: ScaleName, dataValues: RawValue[], markTypes: Set<MarkType>, scaleOptions?: Partial<ScaleOptions>): ScaleType;
+export declare function inferScaleType(name: ScaleName, dataValues: RawValue[], markTypes: Set<MarkType>): ScaleType;
 /**
  * Mark channels can explicitly or implicitly be exempt from being
  * mapped to a scale, so everywhere where values are being mapped to

package/dist/helpers/scales.js

@@ -1,5 +1,5 @@
 import { extent, ascending } from 'd3-array';
-import { isColorOrNull, isDate, isDateOrNull, isNumberOrNull, isNumberOrNullOrNaN, isStringOrNull } from './typeChecks.js';
+import { isColorOrNull, isDateOrNull, isNumberOrNull, isNumberOrNullOrNaN, isStringOrNull } from './typeChecks.js';
 import { CHANNEL_SCALE, VALID_SCALE_TYPES } from '../constants.js';
 import { isSymbolOrNull } from './typeChecks.js';
 import { resolveProp, toChannelOption } from './resolve.js';
@@ -146,7 +146,7 @@ export function createScale(name, scaleOptions, marks, plotOptions, plotWidth, p
     // construct domain from data values
     const valueArr = [...dataValues.values(), ...(scaleOptions.domain || [])].filter((d) => d != null);
     const type = scaleOptions.type === 'auto'
-        ? inferScaleType(name, valueArr, markTypes, scaleOptions)
+        ? inferScaleType(name, valueArr, markTypes)
         : scaleOptions.type;
     if (VALID_SCALE_TYPES[name] && !VALID_SCALE_TYPES[name].has(type)) {
         throw new Error(`Invalid scale type ${type} for scale
@@ -217,15 +217,11 @@ function domainFromInterval(domain, interval, name) {
     const out = interval_.range(lo, interval_.offset(hi));
     return name === 'y' ? out.toReversed() : out;
 }
-const markTypesWithBandDefault = {
-    x: new Set(['barY', 'cell', 'tickY']),
-    y: new Set(['barX', 'cell', 'tickX'])
-};
 /**
  * Infer a scale type based on the scale name, the data values mapped to it and
  * the mark types that are bound to the scale
  */
-export function inferScaleType(name, dataValues, markTypes, scaleOptions = {}) {
+export function inferScaleType(name, dataValues, markTypes) {
     if (name === 'color') {
         if (!dataValues.length)
             return 'ordinal';
@@ -239,22 +235,15 @@ export function inferScaleType(name, dataValues, markTypes, scaleOptions = {}) {
     }
     if (name === 'symbol')
         return 'ordinal';
+    // for positional scales, try to pick a scale that's required by the mark types
     if (name === 'x' || name === 'y') {
-        // if for a positional scale we may infer the scale type from the scale options
-        if (scaleOptions.nice || scaleOptions.zero)
-            return 'linear';
-        if (scaleOptions.domain && scaleOptions.domain.length === 2) {
-            if (scaleOptions.domain.every(Number.isFinite))
-                return 'linear';
-            if (scaleOptions.domain.every(isDate))
-                return 'time';
-        }
+        if (name === 'y' &&
+            (markTypes.has('barX') || markTypes.has('tickX') || markTypes.has('cell')))
+            return 'band';
+        if (name === 'x' &&
+            (markTypes.has('barY') || markTypes.has('tickY') || markTypes.has('cell')))
+            return 'band';
     }
-    // for positional scales, try to pick a scale that's required by the mark types
-    if (name === 'y' && Array.from(markTypes).some((d) => markTypesWithBandDefault.y.has(d)))
-        return 'band';
-    if (name === 'x' && Array.from(markTypes).some((d) => markTypesWithBandDefault.x.has(d)))
-        return 'band';
     if (!dataValues.length)
         return 'linear';
     if (dataValues.length === 1)

package/dist/helpers/typeChecks.d.ts

@@ -1,10 +1,10 @@
 import type { RawValue } from '../types/index.js';
-export declare function isBooleanOrNull(v: RawValue): boolean;
+export declare function isBooleanOrNull(v: RawValue): v is boolean;
 export declare function isDate(v: RawValue): v is Date;
-export declare function isDateOrNull(v: RawValue | null | undefined): boolean;
+export declare function isDateOrNull(v: RawValue | null | undefined): v is Date | null | undefined;
 export declare function isNumberOrNull(v: RawValue | null | undefined): boolean;
 export declare function isNumberOrNullOrNaN(v: RawValue | null | undefined): boolean;
-export declare function isStringOrNull(v: RawValue | null | undefined): boolean;
+export declare function isStringOrNull(v: RawValue | null | undefined): v is string | null | undefined;
 export declare function isSymbolOrNull(v: RawValue | null | undefined): boolean;
-export declare function isColorOrNull(v: RawValue | null | undefined): any;
+export declare function isColorOrNull(v: RawValue | null | undefined): boolean;
 export declare function isOpacityOrNull(v: RawValue): boolean;

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

@@ -1,17 +1,14 @@
 import { type CurveFactory } from 'd3-shape';
-import callWithProps from '../helpers/callWithProps.js';
 import type { CurveName, DataRecord, ConstantAccessor, ChannelAccessor, LinkableMarkProps, RawValue } from '../types/index.js';
 import type { StackOptions } from '../transforms/stack.js';
 declare class __sveltets_Render<Datum extends DataRecord> {
     props(): Partial<{
-        filter: ConstantAccessor<boolean, Datum>;
-        facet: "auto" | "include" | "exclude";
+        filter?: ConstantAccessor<boolean, Datum>;
+        facet?: "auto" | "include" | "exclude";
         fx: ChannelAccessor<Datum>;
         fy: ChannelAccessor<Datum>;
         dx: ConstantAccessor<number, Datum>;
         dy: ConstantAccessor<number, Datum>;
-        dodgeX: callWithProps;
-        dodgeY: callWithProps;
         fill: ChannelAccessor<Datum>;
         fillOpacity: ConstantAccessor<number, Datum>;
         sort: {
@@ -32,38 +29,38 @@ declare class __sveltets_Render<Datum extends DataRecord> {
         imageFilter: ConstantAccessor<string, Datum>;
         shapeRendering: ConstantAccessor<import("csstype").Property.ShapeRendering, Datum>;
         paintOrder: ConstantAccessor<string, Datum>;
-        onclick: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondblclick: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmouseup: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmousedown: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmouseenter: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmousemove: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmouseleave: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmouseout: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmouseover: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointercancel: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerdown: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerup: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerenter: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerleave: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointermove: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerover: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerout: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondrag: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondrop: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondragstart: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondragenter: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondragleave: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondragover: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondragend: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ontouchstart: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ontouchmove: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ontouchend: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ontouchcancel: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        oncontextmenu: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onwheel: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        class: string;
-        style: string;
+        onclick?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondblclick?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmouseup?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmousedown?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmouseenter?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmousemove?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmouseleave?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmouseout?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmouseover?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointercancel?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerdown?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerup?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerenter?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerleave?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointermove?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerover?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerout?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondrag?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondrop?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondragstart?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondragenter?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondragleave?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondragover?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondragend?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ontouchstart?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ontouchmove?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ontouchend?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ontouchcancel?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        oncontextmenu?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onwheel?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        class?: string;
+        style?: string;
         cursor: ConstantAccessor<import("csstype").Property.Cursor, Datum>;
     }> & LinkableMarkProps<Datum> & {
         data: Datum[];

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

@@ -1,15 +1,12 @@
-import { renameChannels } from '../transforms/rename.js';
 import type { ChannelAccessor, DataRow } from '../types/index.js';
 declare class __sveltets_Render<Datum extends DataRow> {
     props(): Omit<Partial<{
-        filter: import("../types/index.js").ConstantAccessor<boolean, Record<string | symbol, import("../types/data").RawValue>>;
-        facet: "auto" | "include" | "exclude";
+        filter?: import("../types/index.js").ConstantAccessor<boolean, Record<string | symbol, import("../types/data").RawValue>>;
+        facet?: "auto" | "include" | "exclude";
         fx: ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
         fy: ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
         dx: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data").RawValue>>;
         dy: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data").RawValue>>;
-        dodgeX: renameChannels;
-        dodgeY: renameChannels;
         fill: ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
         fillOpacity: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data").RawValue>>;
         sort: {
@@ -30,38 +27,38 @@ declare class __sveltets_Render<Datum extends DataRow> {
         imageFilter: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/data").RawValue>>;
         shapeRendering: import("../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, Record<string | symbol, import("../types/data").RawValue>>;
         paintOrder: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/data").RawValue>>;
-        onclick: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondblclick: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmouseup: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmousedown: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmouseenter: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmousemove: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmouseleave: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmouseout: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmouseover: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointercancel: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerdown: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerup: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerenter: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerleave: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointermove: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerover: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerout: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondrag: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondrop: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondragstart: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondragenter: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondragleave: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondragover: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondragend: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ontouchstart: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ontouchmove: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ontouchend: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ontouchcancel: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        oncontextmenu: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onwheel: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        class: string;
-        style: string;
+        onclick?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondblclick?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmouseup?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmousedown?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmouseenter?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmousemove?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmouseleave?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmouseout?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onmouseover?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointercancel?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerdown?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerup?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerenter?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerleave?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointermove?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerover?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onpointerout?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondrag?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondrop?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondragstart?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondragenter?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondragleave?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondragover?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ondragend?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ontouchstart?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ontouchmove?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ontouchend?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        ontouchcancel?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        oncontextmenu?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        onwheel?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+        class?: string;
+        style?: string;
         cursor: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Record<string | symbol, import("../types/data").RawValue>>;
     }> & import("../types/mark").LinkableMarkProps<Record<string | symbol, import("../types/data").RawValue>> & {
         data: Record<string | symbol, import("../types/data").RawValue>[];
@@ -75,7 +72,7 @@ declare class __sveltets_Render<Datum extends DataRow> {
         sort?: import("../types/index.js").ConstantAccessor<import("../types/data").RawValue> | {
             channel: "stroke" | "fill";
         };
-        stack?: Partial<renameChannels>;
+        stack?: Partial<import("../transforms/stack.js").StackOptions>;
         canvas?: boolean;
     }, "y1" | "y2"> & {
         x?: ChannelAccessor<Datum>;