svelteplot 0.6.0-pr-266.0 → 0.7.0

package/dist/Mark.svelte

@@ -152,6 +152,12 @@
                     if (options?.[channel] !== undefined && out[channel] === undefined) {
                         // resolve value
                         out[channel] = resolveChannel(channel, row, options);
+                        if (options[channel] === INDEX) {
+                            const scale = plot.scales[CHANNEL_SCALE[channel]];
+                            if (scale.type === 'band' || scale.type === 'point') {
+                                out[channel] = scale.domain[out[channel] % scale.domain.length];
+                            }
+                        }
                     }
                 }
                 return [out];
@@ -212,6 +218,7 @@
             resolvedData.flatMap((row) => {
                 const out: ScaledDataRecord<Datum> = {
                     datum: row.datum,
+                    resolved: row,
                     index: row[INDEX],
                     valid: true
                 };

package/dist/Mark.svelte.d.ts

@@ -1,5 +1,4 @@
 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> {
@@ -10,14 +9,14 @@ declare class __sveltets_Render<Datum extends DataRecord> {
         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;
+        dodgeX: import("./transforms/dodge.js").DodgeXOptions;
+        dodgeY: import("./transforms/dodge.js").DodgeYOptions;
         fill: ChannelAccessor<Datum>;
         fillOpacity: import("./types/index.js").ConstantAccessor<number, Datum>;
-        sort: {
+        sort: ((a: RawValue, b: RawValue) => number) | {
             channel: string;
             order?: "ascending" | "descending";
-        } | ((a: RawValue, b: RawValue) => number) | import("./types/index.js").ConstantAccessor<RawValue, Datum>;
+        } | import("./types/index.js").ConstantAccessor<RawValue, Datum>;
         stroke: ChannelAccessor<Datum>;
         strokeWidth: import("./types/index.js").ConstantAccessor<number, Datum>;
         strokeOpacity: import("./types/index.js").ConstantAccessor<number, Datum>;

package/dist/Plot.svelte

@@ -12,7 +12,7 @@
 <script lang="ts">
     import Plot from './core/Plot.svelte';
 
-    import type { PlotOptions } from './types/index.js';
+    import type { PlotOptions, RawValue, ScaleOptions } from './types/index.js';
 
     // implicit marks
     import AxisX from './marks/AxisX.svelte';
@@ -62,12 +62,20 @@
     const scales = $derived(
         Object.fromEntries(
             ['x', 'y', 'r', 'color', 'opacity', 'symbol', 'length', 'fx', 'fy'].map((scale) => {
-                const scaleOpts = restOptions[scale] || {};
+                const scaleOpts = maybeScaleOptions(restOptions[scale]);
                 const scaleFn = scaleOpts.scale || (scale === 'color' ? autoScaleColor : autoScale);
                 return [scale, { ...scaleOpts, scale: scaleFn }];
             })
         )
     );
+
+    function maybeScaleOptions(
+        scaleOptions: undefined | false | RawValue[] | object
+    ): Partial<ScaleOptions> | undefined {
+        if (scaleOptions === false) return { axis: false };
+        if (Array.isArray(scaleOptions)) return { domain: scaleOptions };
+        return scaleOptions || {};
+    }
 </script>
 
 {#snippet header()}

package/dist/constants.d.ts

@@ -13,4 +13,4 @@ export declare const CSS_COLOR_MIX: RegExp;
 export declare const CSS_COLOR_CONTRAST: RegExp;
 export declare const CSS_RGBA: RegExp;
 export declare const CSS_URL: RegExp;
-export declare const INDEX: any;
+export declare const INDEX: unique symbol;

package/dist/core/FacetAxes.svelte

@@ -35,7 +35,7 @@
             scaleFn={facetXScale}
             scaleType="band"
             ticks={fxValues}
-            tickFormat={(d) => d}
+            tickFormat={plot.options.fx.tickFormat || ((d) => d)}
             tickFontSize={11}
             tickSize={0}
             tickPadding={5}
@@ -53,7 +53,7 @@
             scaleFn={facetYScale}
             scaleType="band"
             ticks={fyValues}
-            tickFormat={(d) => d}
+            tickFormat={plot.options.fy.tickFormat || ((d) => d)}
             tickFontSize={11}
             tickSize={0}
             tickPadding={5}

package/dist/core/Plot.svelte

@@ -114,7 +114,7 @@
         class: className = '',
         css = DEFAULTS.css,
         width: fixedWidth,
-        ...initialOpts
+        ...initialOptions
     }: Partial<PlotOptions> = $props();
 
     let width = $state(DEFAULTS.initialWidth);
@@ -164,7 +164,7 @@
     );
 
     const explicitDomains = $derived(
-        new Set(SCALES.filter((scale) => !!initialOpts[scale]?.domain))
+        new Set(SCALES.filter((scale) => !!initialOptions[scale]?.domain))
     );
 
     // one-dimensional plots have different automatic margins and heights
@@ -173,12 +173,12 @@
     // construct the plot options from the user-defined options (top-level props) as well
     // as extending them from smart context-aware defaults
     const plotOptions = $derived(
-        extendPlotOptions(initialOpts, {
+        extendPlotOptions(initialOptions, {
             explicitScales,
             explicitDomains,
-            hasProjection: !!initialOpts.projection,
-            margin: initialOpts.margin,
-            inset: initialOpts.inset
+            hasProjection: !!initialOptions.projection,
+            margin: initialOptions.margin,
+            inset: initialOptions.inset
         })
     );
 
@@ -369,7 +369,7 @@
             {},
             { sortOrdinalDomains: DEFAULTS.sortOrdinalDomains },
             smartDefaultPlotOptions(opts),
-            initialOpts
+            initialOptions
         );
     }
 
@@ -614,10 +614,6 @@
         border: 0 !important;
     }
 
-    .plot-header :global(h3) {
-        font-weight: 500;
-    }
-
     .plot-footer {
         margin-bottom: 2rem;
     }

package/dist/helpers/colors.d.ts

@@ -1,10 +1,13 @@
+import { interpolateBrBG } from 'd3-scale-chromatic';
 import type { ColorScheme } from '../types/index.js';
-export declare const categoricalSchemes: any;
-export declare function isCategoricalScheme(scheme: string): any;
-export declare function isOrdinalScheme(scheme: ColorScheme): any;
-export declare function ordinalScheme(scheme: string): any;
-export declare function ordinalRange(scheme: string, length: number): any;
-export declare function maybeBooleanRange(domain: boolean[], scheme?: string): any[] | undefined;
-export declare function isQuantitativeScheme(scheme: string): any;
-export declare function quantitativeScheme(scheme: string): any;
-export declare function isDivergingScheme(scheme: string): any;
+export declare const categoricalSchemes: Map<string, readonly string[]>;
+export declare function isCategoricalScheme(scheme: string): boolean;
+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): 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;
+export {};

package/dist/helpers/facets.d.ts

@@ -9,4 +9,4 @@ import type { GenericMarkOptions, Mark, RawValue } from '../types/index.js';
  * @param fyValues y facet domain
  * @returns
  */
-export declare function getEmptyFacets(marks: Mark<GenericMarkOptions>[], fxValues: RawValue[], fyValues: RawValue[]): any;
+export declare function getEmptyFacets(marks: Mark<GenericMarkOptions>[], fxValues: RawValue[], fyValues: RawValue[]): Map<RawValue, Map<RawValue, boolean>>;

package/dist/helpers/getBaseStyles.d.ts

@@ -1,7 +1,11 @@
 import type { Channels } from '../types/index.js';
 import type { DataRow } from '../types/index.js';
-export declare function getBaseStylesObject(datum: DataRow, props: Partial<Channels>): any;
-export default function (datum: DataRow, props: Partial<Channels>): any;
+export declare function getBaseStylesObject(datum: DataRow, props: Partial<Channels>): {
+    [k: string]: string | number;
+};
+export default function (datum: DataRow, props: Partial<Channels>): string;
 export declare function maybeToPixel(cssKey: string, value: string | number): string | number;
 export declare function maybeFromPixel(value: string | number): string | number;
 export declare function maybeFromRem(value: string | number, rootFontSize?: number): string | number;
+export declare function getClipId(): string;
+export declare function getPatternId(): string;

package/dist/helpers/getBaseStyles.js

@@ -54,3 +54,11 @@ export function maybeFromRem(value, rootFontSize = 16) {
         ? +value.slice(0, -3) * rootFontSize
         : value;
 }
+let nextClipId = 0;
+let nextPatternId = 0;
+export function getClipId() {
+    return `svp-clip-${++nextClipId}`;
+}
+export function getPatternId() {
+    return `svp-pattern-${++nextPatternId}`;
+}

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)[]): string | number | boolean | symbol | object | 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;
@@ -15,4 +15,4 @@ export declare const POSITION_CHANNELS: Set<ChannelName>;
 export declare function parseInset(inset: number | string, width: number): number;
 export declare function omit<T extends {}, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K>;
 export declare function identity<T>(x: T): T;
-export declare const GEOJSON_PREFER_STROKE: any;
+export declare const GEOJSON_PREFER_STROKE: Set<string>;

package/dist/helpers/reduce.d.ts

@@ -4,7 +4,7 @@ type ReducerOption = ReducerName | ReducerFunc;
 type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
 export type ReducerPercentile = (`p${Digit}${Digit}` & Record<never, never>) | 'p25' | 'p50' | 'p75';
 export type ReducerName = 'count' | 'deviation' | 'difference' | 'first' | 'last' | 'max' | 'mean' | 'median' | 'min' | 'mode' | 'ratio' | 'sum' | 'variance' | ReducerPercentile;
-export declare const Reducer: any;
+export declare const Reducer: Record<ReducerName, ReducerFunc>;
 export declare function mayberReducer(r: ReducerOption): ReducerFunc;
 export declare function reduceOutputs(newDatum: DataRecord, data: DataRecord[], options: Record<ChannelName, ReducerOption>, outputs: Iterable<ChannelName>, channels: Channels, newChannels: Channels): void;
 export {};

package/dist/helpers/removeIdenticalLines.js

@@ -12,10 +12,11 @@ export default function removeIdenticalLines(input) {
             text: []
         });
     }
-    for (let l = 0; l < input[0].text.length; l++) {
+    const maxLines = Math.max(...input.map((t) => t.text.length));
+    for (let l = 0; l < maxLines; l++) {
         const isIdentical = input.length > 1 && input.every((tick) => input[0].text[l] === tick.text[l]);
         for (let c = 0; c < input.length; c++) {
-            if (!isIdentical && input[c].text[l])
+            if (!isIdentical && input[c].text[l] != null)
                 uniqueTicks[c].text.push(input[c].text[l]);
         }
     }

package/dist/helpers/scales.d.ts

@@ -1,4 +1,4 @@
-import type { GenericMarkOptions, Mark, MarkType, PlotDefaults, PlotOptions, PlotScales, PlotState, RawValue, ScaleName, ScaleOptions, ScaleType, UsedScales } from '../types/index.js';
+import type { ChannelAccessor, GenericMarkOptions, Mark, MarkType, PlotDefaults, PlotOptions, PlotScales, PlotState, RawValue, ScaleName, ScaleOptions, ScaleType, ScaledChannelName, UsedScales } from '../types/index.js';
 /**
  * compute the plot scales
  */
@@ -8,19 +8,19 @@ export declare function createScale<T extends ScaleOptions>(name: ScaleName, sca
     domain: number[];
     range: number[];
     fn: (() => string) | (() => number);
-    skip: any;
+    skip: Map<any, any>;
     isDummy: boolean;
     manualActiveMarks?: undefined;
     uniqueScaleProps?: undefined;
     autoTitle?: undefined;
 } | {
     type: ScaleType;
-    domain: any;
+    domain: RawValue[] | [undefined, undefined];
     range: any;
     fn: any;
-    skip: any;
+    skip: Map<ScaledChannelName, Set<symbol>>;
     manualActiveMarks: number;
-    uniqueScaleProps: any;
+    uniqueScaleProps: Set<ChannelAccessor>;
     autoTitle: string | null;
     isDummy?: undefined;
 };
@@ -36,8 +36,8 @@ export declare function inferScaleType(name: ScaleName, dataValues: RawValue[],
  * not. That's what this function is used for.
  */
 export declare function getUsedScales(plot: PlotState, options: GenericMarkOptions, mark: Mark<GenericMarkOptions>): UsedScales;
-export declare function looksLikeANumber(input: string | number): any;
+export declare function looksLikeANumber(input: string | number): boolean;
 export declare function projectXY(scales: PlotScales, x: RawValue, y: RawValue, useXScale?: boolean, useYScale?: boolean): [number, number];
 export declare function projectX(channel: 'x' | 'x1' | 'x2', scales: PlotScales, value: RawValue): number;
 export declare function projectY(channel: 'y' | 'y1' | 'y2', scales: PlotScales, value: RawValue): number;
-export declare function isOrdinalScale(scaleType: ScaleType): scaleType is "point" | "ordinal" | "band" | "categorical" | "threshold";
+export declare function isOrdinalScale(scaleType: ScaleType): scaleType is "ordinal" | "point" | "band" | "categorical" | "threshold";

package/dist/helpers/scales.js

@@ -218,8 +218,8 @@ function domainFromInterval(domain, interval, name) {
     return name === 'y' ? out.toReversed() : out;
 }
 const markTypesWithBandDefault = {
-    x: new Set(['barY', 'cell', 'tickY']),
-    y: new Set(['barX', 'cell', 'tickX'])
+    x: new Set(['barY', 'cell', 'tickY', 'waffleY']),
+    y: new Set(['barX', 'cell', 'tickX', 'waffleX'])
 };
 /**
  * Infer a scale type based on the scale name, the data values mapped to it and

package/dist/helpers/symbols.d.ts

@@ -1,5 +1,5 @@
 import { type SymbolType } from 'd3-shape';
 export declare const sqrt3: number;
 export declare const sqrt4_3: number;
-export declare function isSymbol(value: string | SymbolType): any;
-export declare function maybeSymbol(symbol: SymbolType | string): any;
+export declare function isSymbol(value: string | SymbolType): boolean;
+export declare function maybeSymbol(symbol: SymbolType | string): SymbolType;

package/dist/helpers/time.d.ts

@@ -1,6 +1,6 @@
-export declare const durations: any;
-export declare const intervalDuration: any;
-export declare const intervalType: any;
+export declare const durations: Map<string, number>;
+export declare const intervalDuration: unique symbol;
+export declare const intervalType: unique symbol;
 export declare function parseTimeInterval(input: string): [string, number];
 export declare function maybeTimeInterval(input: string): any;
 export declare function maybeUtcInterval(input: string): any;

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 isNumberOrNull(v: RawValue | null | undefined): any;
-export declare function isNumberOrNullOrNaN(v: RawValue | null | undefined): any;
-export declare function isStringOrNull(v: RawValue | null | undefined): boolean;
-export declare function isSymbolOrNull(v: RawValue | null | undefined): any;
-export declare function isColorOrNull(v: RawValue | null | undefined): any;
-export declare function isOpacityOrNull(v: RawValue): any;
+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): v is string | null | undefined;
+export declare function isSymbolOrNull(v: RawValue | null | undefined): boolean;
+export declare function isColorOrNull(v: RawValue | null | undefined): boolean;
+export declare function isOpacityOrNull(v: RawValue): boolean;

package/dist/helpers/wordwrap.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Greedy word-wrapping that approximates visual width by character widths.
+ *
+ * - Splits input into words, additionally breaking on `-` to avoid very long segments.
+ * - Uses a rough character width table to approximate line widths.
+ * - Wraps once the maximum visual width is exceeded, but only after a minimum.
+ */
+export default function wordwrap(line: string, { maxCharactersPerLine, maxLineWidth }: {
+    maxCharactersPerLine?: number;
+    maxLineWidth?: number;
+}, { minCharactersPerLine, minLineWidth }: {
+    minCharactersPerLine?: number;
+    minLineWidth?: number;
+}, fontSize?: number, monospace?: boolean): string[];

package/dist/helpers/wordwrap.js

@@ -0,0 +1,129 @@
+import { sum } from 'd3-array';
+// Per-character width table for a typical proportional font.
+// This is not perfect for all fonts, but is better than treating
+// all characters as equal width. Set `monospace = true` to bypass.
+const CHAR_W = {
+    A: 7,
+    a: 7,
+    B: 8,
+    b: 7,
+    C: 8,
+    c: 6,
+    D: 9,
+    d: 7,
+    E: 7,
+    e: 7,
+    F: 7,
+    f: 4,
+    G: 9,
+    g: 7,
+    H: 9,
+    h: 7,
+    I: 3,
+    i: 3,
+    J: 5,
+    j: 3,
+    K: 8,
+    k: 6,
+    L: 7,
+    l: 3,
+    M: 11,
+    m: 11,
+    N: 9,
+    n: 7,
+    O: 9,
+    o: 7,
+    P: 8,
+    p: 7,
+    Q: 9,
+    q: 7,
+    R: 8,
+    r: 4,
+    S: 8,
+    s: 6,
+    T: 7,
+    t: 4,
+    U: 9,
+    u: 7,
+    V: 7,
+    v: 6,
+    W: 11,
+    w: 9,
+    X: 7,
+    x: 6,
+    Y: 7,
+    y: 6,
+    Z: 7,
+    z: 5,
+    '.': 2,
+    ',': 2,
+    ':': 2,
+    ';': 2
+};
+/**
+ * Greedy word-wrapping that approximates visual width by character widths.
+ *
+ * - Splits input into words, additionally breaking on `-` to avoid very long segments.
+ * - Uses a rough character width table to approximate line widths.
+ * - Wraps once the maximum visual width is exceeded, but only after a minimum.
+ */
+export default function wordwrap(line, { maxCharactersPerLine, maxLineWidth }, { minCharactersPerLine, minLineWidth }, fontSize = 12, monospace = false) {
+    // Tokenized words (with hyphen-splitting applied) including trailing spaces/hyphens.
+    const tokens = [];
+    // First split by spaces, then further split by hyphens so we can
+    // wrap inside hyphenated words if necessary.
+    const spaceSeparated = line.split(' ');
+    spaceSeparated.forEach((word, wordIndex) => {
+        const hyphenParts = word.split('-');
+        const trailingWhitespace = wordIndex < spaceSeparated.length - 1 ? ' ' : '';
+        if (hyphenParts.length > 1) {
+            hyphenParts.forEach((part, partIndex) => {
+                const suffix = partIndex < hyphenParts.length - 1 ? '-' : trailingWhitespace;
+                tokens.push(part + suffix);
+            });
+        }
+        else {
+            tokens.push(word + trailingWhitespace);
+        }
+    });
+    const maxChars = maxCharactersPerLine || 40;
+    if (!maxLineWidth) {
+        // Fallback for max characters per line if not provided / falsy.
+        // Convert character counts into approximate visual widths.
+        maxLineWidth = maxChars * CHAR_W.a;
+    }
+    if (!minLineWidth) {
+        // Estimate a good minimum line length:
+        //  - start from either a provided value or
+        //  - clamp a scaled median word length between 3 and half of maxChars.
+        const sortedWordLengths = tokens.map((t) => t.length).sort((a, b) => a - b);
+        const medianIndex = Math.round(tokens.length / 2);
+        const medianWordLength = sortedWordLengths[medianIndex] ?? maxChars;
+        const minChars = minCharactersPerLine || Math.max(3, Math.min(maxChars * 0.5, 0.75 * medianWordLength));
+        minLineWidth = minChars * CHAR_W.a;
+    }
+    const lines = [];
+    const currentWords = [];
+    let currentWidth = 0;
+    // Helper to look up a character width, falling back to "a" if unknown
+    // or when monospace mode is enabled.
+    const charWidth = (char) => (fontSize / 12) * (!monospace ? CHAR_W[char] : CHAR_W.a);
+    // Greedy line construction: append tokens until the next one would exceed
+    // max visual width, but only break if the line has passed the minimum width.
+    tokens.forEach((token) => {
+        const tokenWidth = sum(token.split('').map(charWidth));
+        if (currentWidth + tokenWidth > maxLineWidth && currentWidth > minLineWidth) {
+            lines.push(currentWords.join(''));
+            currentWords.length = 0;
+            currentWidth = 0;
+        }
+        currentWidth += tokenWidth;
+        currentWords.push(token);
+    });
+    // Flush trailing tokens into the last line.
+    if (currentWords.length > 0) {
+        lines.push(currentWords.join(''));
+    }
+    // Filter out any empty lines that may have been created.
+    return lines.filter((d) => d !== '');
+}

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

@@ -1,5 +1,4 @@
 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> {
@@ -10,14 +9,14 @@ declare class __sveltets_Render<Datum extends DataRecord> {
         fy: ChannelAccessor<Datum>;
         dx: ConstantAccessor<number, Datum>;
         dy: ConstantAccessor<number, Datum>;
-        dodgeX: callWithProps;
-        dodgeY: callWithProps;
+        dodgeX: import("../transforms/dodge").DodgeXOptions;
+        dodgeY: import("../transforms/dodge").DodgeYOptions;
         fill: ChannelAccessor<Datum>;
         fillOpacity: ConstantAccessor<number, Datum>;
-        sort: {
+        sort: ((a: RawValue, b: RawValue) => number) | {
             channel: string;
             order?: "ascending" | "descending";
-        } | ((a: RawValue, b: RawValue) => number) | ConstantAccessor<RawValue, Datum>;
+        } | ConstantAccessor<RawValue, Datum>;
         stroke: ChannelAccessor<Datum>;
         strokeWidth: ConstantAccessor<number, Datum>;
         strokeOpacity: ConstantAccessor<number, Datum>;

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

@@ -1,4 +1,3 @@
-import { renameChannels } from '../transforms/rename.js';
 import type { ChannelAccessor, DataRow } from '../types/index.js';
 declare class __sveltets_Render<Datum extends DataRow> {
     props(): Omit<Partial<{
@@ -8,14 +7,14 @@ declare class __sveltets_Render<Datum extends DataRow> {
         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;
+        dodgeX: import("../transforms/dodge").DodgeXOptions;
+        dodgeY: import("../transforms/dodge").DodgeYOptions;
         fill: ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
         fillOpacity: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data").RawValue>>;
-        sort: {
+        sort: ((a: import("../types/data").RawValue, b: import("../types/data").RawValue) => number) | {
             channel: string;
             order?: "ascending" | "descending";
-        } | ((a: import("../types/data").RawValue, b: import("../types/data").RawValue) => number) | import("../types/index.js").ConstantAccessor<import("../types/data").RawValue, Record<string | symbol, import("../types/data").RawValue>>;
+        } | import("../types/index.js").ConstantAccessor<import("../types/data").RawValue, Record<string | symbol, import("../types/data").RawValue>>;
         stroke: ChannelAccessor<Record<string | symbol, import("../types/data").RawValue>>;
         strokeWidth: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data").RawValue>>;
         strokeOpacity: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/data").RawValue>>;
@@ -75,7 +74,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;
         areaClass?: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/data").RawValue>>;
     }, "y1" | "y2"> & {

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

@@ -1,6 +1,5 @@
 import type { DataRecord, ConstantAccessor, ChannelAccessor, RawValue } from '../types/index.js';
 import { type SweepOption } from '../helpers/arrowPath.js';
-import { replaceChannels } from '../transforms/rename.js';
 declare class __sveltets_Render<Datum extends DataRecord> {
     props(): Omit<Partial<{
         filter: ConstantAccessor<boolean, Datum>;
@@ -9,14 +8,14 @@ declare class __sveltets_Render<Datum extends DataRecord> {
         fy: ChannelAccessor<Datum>;
         dx: ConstantAccessor<number, Datum>;
         dy: ConstantAccessor<number, Datum>;
-        dodgeX: replaceChannels;
-        dodgeY: replaceChannels;
+        dodgeX: import("../transforms/dodge.js").DodgeXOptions;
+        dodgeY: import("../transforms/dodge.js").DodgeYOptions;
         fill: ChannelAccessor<Datum>;
         fillOpacity: ConstantAccessor<number, Datum>;
-        sort: {
+        sort: ((a: RawValue, b: RawValue) => number) | {
             channel: string;
             order?: "ascending" | "descending";
-        } | ((a: RawValue, b: RawValue) => number) | ConstantAccessor<RawValue, Datum>;
+        } | ConstantAccessor<RawValue, Datum>;
         stroke: ChannelAccessor<Datum>;
         strokeWidth: ConstantAccessor<number, Datum>;
         strokeOpacity: ConstantAccessor<number, Datum>;

package/dist/marks/AxisX.svelte

@@ -51,6 +51,7 @@
         tickSpacing?: number;
         /** text anchor for axis labels */
         textAnchor?: ConstantAccessor<CSS.Property.TextAnchor | 'auto', Datum>;
+        removeDuplicateTicks: boolean;
     }
 
     let markProps: AxisXMarkProps = $props();
@@ -223,7 +224,7 @@
             {anchor}
             {className}
             {labelAnchor}
-            {options}
+            options={{ ...options, ...plot.options.x }}
             {plot}
             {text}
             {tickClass}