svelteplot 0.4.5-pr-209.2 → 0.4.5-pr-208.3

package/dist/Mark.svelte

@@ -41,6 +41,7 @@
     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 = [],
@@ -207,85 +208,98 @@
      * elements to the scales
      */
     const scaledData = $derived(
-        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);
+        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);
+                        }
                     }
                 }
-            }
 
-            // 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];
-        })
+                return [out];
+            }),
+            options
+        )
     );
+
+    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,14 +1,17 @@
 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: {
@@ -29,38 +32,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/scales.d.ts

@@ -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>): ScaleType;
+export declare function inferScaleType(name: ScaleName, dataValues: RawValue[], markTypes: Set<MarkType>, scaleOptions?: Partial<ScaleOptions>): 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, isDateOrNull, isNumberOrNull, isNumberOrNullOrNaN, isStringOrNull } from './typeChecks.js';
+import { isColorOrNull, isDate, 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)
+        ? inferScaleType(name, valueArr, markTypes, scaleOptions)
         : scaleOptions.type;
     if (VALID_SCALE_TYPES[name] && !VALID_SCALE_TYPES[name].has(type)) {
         throw new Error(`Invalid scale type ${type} for scale
@@ -217,11 +217,15 @@ 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) {
+export function inferScaleType(name, dataValues, markTypes, scaleOptions = {}) {
     if (name === 'color') {
         if (!dataValues.length)
             return 'ordinal';
@@ -235,15 +239,22 @@ export function inferScaleType(name, dataValues, markTypes) {
     }
     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 (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';
+        // 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';
+        }
     }
+    // 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/marks/Area.svelte.d.ts

@@ -1,14 +1,17 @@
 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: {
@@ -29,38 +32,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

@@ -2,12 +2,14 @@ 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: {
@@ -28,38 +30,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>[];