layerchart 2.0.0-next.0 → 2.0.0-next.2

package/dist/utils/scales.svelte.d.ts

@@ -0,0 +1,90 @@
+import { type ScaleBand } from 'd3-scale';
+import { type MotionProp, type MotionOptions, type SpringOptions, type TweenOptions } from './motion.svelte.js';
+import type { Accessor } from './common.js';
+import type { OnlyObjects } from './types.js';
+export type AnyScale<TInput extends SingleDomainType = any, TOutput extends SingleDomainType = any, TScaleArgs extends any[] | readonly any[] = any[]> = {
+    (value: TInput): TOutput;
+    domain(domain: TInput[] | readonly TInput[]): AnyScale<TInput, TOutput, TScaleArgs>;
+    domain(): TInput[];
+    range(range: TOutput[] | readonly TOutput[]): AnyScale<TInput, TOutput, TScaleArgs>;
+    range(): TOutput[];
+    rangeRound?: (range: TOutput[] | readonly TOutput[]) => AnyScale<TInput, TOutput, TScaleArgs>;
+    copy: () => AnyScale<TInput, TOutput, TScaleArgs>;
+    invert?: (value: TOutput) => TInput;
+    invertExtent?: (value: TOutput) => [TInput, TInput];
+    bandwidth?: () => number;
+    ticks?: (count?: number) => TInput[];
+    tickFormat?: (count?: number) => (value: TInput) => string;
+    clamp?: (clamp: boolean) => AnyScale<TInput, TOutput, TScaleArgs>;
+    interpolate?: (interpolate: (a: TOutput, b: TOutput) => (t: number) => TOutput) => AnyScale<TInput, TOutput, TScaleArgs>;
+    nice?: (count?: number) => AnyScale<TInput, TOutput, TScaleArgs>;
+    interpolator?(interpolator: (t: number) => TOutput): AnyScale<TInput, TOutput, TScaleArgs>;
+    interpolator?(): (t: number) => TOutput;
+    thresholds?: () => TInput[];
+    quantiles?: () => TInput[];
+};
+export declare function getRange(scale: any): any[];
+export type SingleDomainType = number | string | Date | null | undefined;
+export type DomainType = (number | string | Date | null | undefined)[] | null | undefined;
+export declare function createMotionScale<Domain, Range>(scale: AnyScale, motion: MotionProp | undefined, options: {
+    defaultDomain?: Domain;
+    defaultRange?: Range;
+}): {
+    readonly current: any;
+    domain: (values: Domain) => Promise<void>;
+    range: (values: Range) => Promise<void>;
+};
+/**
+ * Implementation for missing `scaleBand().invert()`
+ *
+ *  See: https://stackoverflow.com/questions/38633082/d3-getting-invert-value-of-band-scales
+ *      https://github.com/d3/d3-scale/pull/64
+ *      https://github.com/vega/vega-scale/blob/master/src/scaleBand.js#L118
+ *      https://observablehq.com/@d3/ordinal-brushing
+ * 			https://github.com/d3/d3-scale/blob/11777dac7d4b0b3e229d658aee3257ea67bd5ffa/src/band.js#L32
+ * 			https://gist.github.com/LuisSevillano/d53a1dc529eef518780c6df99613e2fd
+ */
+export declare function scaleBandInvert(scale: ScaleBand<any>): (value: number) => any;
+export declare function isScaleBand(scale: AnyScale<any, any>): scale is ScaleBand<any>;
+/**
+ *  Generic way to invert a scale value, handling scaleBand and continuous scales (linear, time, etc).
+ *  Useful to map mouse event location (x,y) to domain value
+ */
+export declare function scaleInvert(scale: AnyScale<any, any>, value: number): any;
+/** Create new copy of scale with domain and range */
+export declare function createScale(scale: AnyScale, domain: DomainType, range: any[] | readonly any[] | Function, context?: Record<any, any>): AnyScale<any, any, any[]>;
+/**
+ * Create a `scaleBand()` within another scaleBand()'s bandwidth
+ * (typically a x1 of an x0 scale, used for grouping)
+ */
+export declare function groupScaleBand<Domain extends {
+    toString(): string;
+}>(scale: ScaleBand<Domain>, flatData: any[], groupBy: string, padding?: {
+    inner?: number;
+    outer?: number;
+}): ScaleBand<string>;
+/**
+ * Animate d3-scale as domain and/or range are updated using tweened store
+ */
+export declare function tweenedScale<Domain, Range>(scale: any, tweenedOptions?: TweenOptions): {
+    readonly current: any;
+    domain: (values: Domain) => Promise<void>;
+    range: (values: Range) => Promise<void>;
+};
+/**
+ * Animate d3-scale as domain and/or range are updated using spring store
+ */
+export declare function springScale<Domain, Range>(scale: AnyScale, springOptions?: SpringOptions): {
+    readonly current: any;
+    domain: (values: Domain) => Promise<void>;
+    range: (values: Range) => Promise<void>;
+};
+/**
+ * Create a store wrapper around a d3-scale which interpolates the domain and/or range using `tweened()` or `spring()` stores.  Fallbacks to `writable()` store if not interpolating
+ */
+export declare function motionScale<Domain, Range>(scale: AnyScale, options: OnlyObjects<MotionOptions>): {
+    readonly current: any;
+    domain: (values: Domain) => Promise<void>;
+    range: (values: Range) => Promise<void>;
+};
+export declare function makeAccessor<TData>(acc: Accessor<TData>): (d: TData) => any;

package/dist/utils/{scales.js → scales.svelte.js}

@@ -1,10 +1,42 @@
-import { derived } from 'svelte/store';
-import { tweened, spring } from 'svelte/motion';
-import { motionStore } from '../stores/motionStore.js';
-import { scaleBand } from 'd3-scale';
 import { unique } from '@layerstack/utils';
+import { scaleBand } from 'd3-scale';
+import { createControlledMotion, } from './motion.svelte.js';
+import { Spring, Tween } from 'svelte/motion';
+function isAnyScale(scale) {
+    return typeof scale === 'function' && typeof scale.range === 'function';
+}
+export function getRange(scale) {
+    if (isAnyScale(scale)) {
+        return scale.range();
+    }
+    console.error("[LayerChart] Your scale doesn't have a `.range` method?");
+    return [];
+}
+// this may need to become a getter for options so we can reactively update after mount
+export function createMotionScale(scale, motion, options) {
+    const domain = createControlledMotion(options.defaultDomain, motion);
+    const range = createControlledMotion(options.defaultRange, motion);
+    const motionScale = $derived.by(() => {
+        // @ts-expect-error
+        const scaleInstance = scale.domain ? scale : scale(); // support `scaleLinear` or `scaleLinear()` (which could have `.interpolate()` and others set)
+        if (domain.current) {
+            scaleInstance.domain(domain.current);
+        }
+        if (range.current) {
+            scaleInstance.range(range.current);
+        }
+        return scaleInstance;
+    });
+    return {
+        get current() {
+            return motionScale;
+        },
+        domain: (values) => domain.set(values),
+        range: (values) => range.set(values),
+    };
+}
 /**
- * Implemenation for missing `scaleBand().invert()`
+ * Implementation for missing `scaleBand().invert()`
  *
  *  See: https://stackoverflow.com/questions/38633082/d3-getting-invert-value-of-band-scales
  *      https://github.com/d3/d3-scale/pull/64
@@ -51,7 +83,10 @@ export function createScale(scale, domain, range, context) {
     }
     return scaleCopy;
 }
-/** Create a `scaleBand()` within another scaleBand()'s bandwidth (typically a x1 of an x0 scale, used for grouping) */
+/**
+ * Create a `scaleBand()` within another scaleBand()'s bandwidth
+ * (typically a x1 of an x0 scale, used for grouping)
+ */
 export function groupScaleBand(scale, flatData, groupBy, padding) {
     //
     const groupKeys = unique(flatData.map((d) => d[groupBy]));
@@ -70,20 +105,22 @@ export function groupScaleBand(scale, flatData, groupBy, padding) {
  * Animate d3-scale as domain and/or range are updated using tweened store
  */
 export function tweenedScale(scale, tweenedOptions = {}) {
-    const tweenedDomain = tweened(undefined, tweenedOptions);
-    const tweenedRange = tweened(undefined, tweenedOptions);
-    const tweenedScale = derived([tweenedDomain, tweenedRange], ([domain, range]) => {
-        const scaleInstance = scale.domain ? scale : scale(); // support `scaleLinear` or `scaleLinear()` (which could have `.interpolate()` and others set)
-        if (domain) {
-            scaleInstance.domain(domain);
+    const tweenedDomain = new Tween(undefined, tweenedOptions);
+    const tweenedRange = new Tween(undefined, tweenedOptions);
+    const tweenedScale = $derived.by(() => {
+        const scaledInstance = scale.domain ? scale : scale();
+        if (tweenedDomain.current) {
+            scaledInstance.domain(tweenedDomain.current);
         }
-        if (range) {
-            scaleInstance.range(range);
+        if (tweenedRange.current) {
+            scaledInstance.range(tweenedRange.current);
         }
-        return scaleInstance;
+        return scaledInstance;
     });
     return {
-        subscribe: tweenedScale.subscribe,
+        get current() {
+            return tweenedScale;
+        },
         domain: (values) => tweenedDomain.set(values),
         range: (values) => tweenedRange.set(values),
     };
@@ -92,45 +129,69 @@ export function tweenedScale(scale, tweenedOptions = {}) {
  * Animate d3-scale as domain and/or range are updated using spring store
  */
 export function springScale(scale, springOptions = {}) {
-    const domainStore = spring(undefined, springOptions);
-    const rangeStore = spring(undefined, springOptions);
-    const tweenedScale = derived([domainStore, rangeStore], ([domain, range]) => {
-        // @ts-expect-error
-        const scaleInstance = scale.domain ? scale : scale(); // support `scaleLinear` or `scaleLinear()` (which could have `.interpolate()` and others set)
-        if (domain) {
-            scaleInstance.domain(domain);
+    const domainState = new Spring(undefined, springOptions);
+    const rangeState = new Spring(undefined, springOptions);
+    const sprungScale = $derived.by(() => {
+        // @ts-expect-error - TODO: investigate/fix
+        const scaledInstance = scale.domain ? scale : scale();
+        if (domainState.current) {
+            scaledInstance.domain(domainState.current);
         }
-        if (range) {
-            scaleInstance.range(range);
+        if (rangeState.current) {
+            scaledInstance.range(rangeState.current);
         }
-        return scaleInstance;
+        return scaledInstance;
     });
     return {
-        subscribe: tweenedScale.subscribe,
-        domain: (values) => domainStore.set(values),
-        range: (values) => rangeStore.set(values),
+        get current() {
+            return sprungScale;
+        },
+        domain: (values) => domainState.set(values),
+        range: (values) => rangeState.set(values),
     };
 }
 /**
  * Create a store wrapper around a d3-scale which interpolates the domain and/or range using `tweened()` or `spring()` stores.  Fallbacks to `writable()` store if not interpolating
  */
 export function motionScale(scale, options) {
-    const domainStore = motionStore(undefined, options);
-    const rangeStore = motionStore(undefined, options);
-    const tweenedScale = derived([domainStore, rangeStore], ([domain, range]) => {
+    const domainState = createControlledMotion(undefined, options);
+    const rangeState = createControlledMotion(undefined, options);
+    const tweenedScale = $derived.by(() => {
         // @ts-expect-error
         const scaleInstance = scale.domain ? scale : scale(); // support `scaleLinear` or `scaleLinear()` (which could have `.interpolate()` and others set)
-        if (domain) {
-            scaleInstance.domain(domain);
+        if (domainState.current) {
+            scaleInstance.domain(domainState.current);
         }
-        if (range) {
-            scaleInstance.range(range);
+        if (rangeState.current) {
+            scaleInstance.range(rangeState.current);
         }
         return scaleInstance;
     });
     return {
-        subscribe: tweenedScale.subscribe,
-        domain: (values) => domainStore.set(values),
-        range: (values) => rangeStore.set(values),
+        get current() {
+            return tweenedScale;
+        },
+        domain: (values) => domainState.set(values),
+        range: (values) => rangeState.set(values),
     };
 }
+function canBeZero(val) {
+    if (val === 0)
+        return true;
+    return val;
+}
+export function makeAccessor(acc) {
+    if (!canBeZero(acc))
+        return null;
+    if (Array.isArray(acc)) {
+        return (d) => acc.map((k) => {
+            // @ts-expect-error - TODO: Fix these types
+            return typeof k !== 'function' ? d[k] : k(d);
+        });
+    }
+    else if (typeof acc !== 'function') {
+        // @ts-expect-error - TODO: Fix these types
+        return (d) => d[acc];
+    }
+    return acc;
+}

package/dist/utils/stack.d.ts

@@ -1,6 +1,5 @@
-import { stackOffsetNone, stackOrderNone } from 'd3-shape';
-type OrderType = typeof stackOrderNone;
-type OffsetType = typeof stackOffsetNone;
+type OrderType = typeof import('d3-shape').stackOrderNone;
+type OffsetType = typeof import('d3-shape').stackOffsetNone;
 export declare function groupStackData<TData>(data: TData[], options: {
     xKey: string;
     groupBy?: string;

package/dist/utils/stack.js

@@ -1,5 +1,5 @@
 import { flatGroup, group, max, rollup, sum } from 'd3-array';
-import { stack, stackOffsetNone, stackOrderNone } from 'd3-shape';
+import { stack } from 'd3-shape';
 import { pivotWider } from './pivot.js';
 export function groupStackData(data, options) {
     const dataByKey = group(data, (d) => d[options.xKey]);

package/dist/utils/string.js

@@ -66,3 +66,90 @@ function getPixel(imageData, x, y) {
     var d = imageData.data;
     return [d[i], d[i + 1], d[i + 2], d[i + 3]];
 }
+export function toTitleCase(str) {
+    return str.replace(/^\w/, (d) => d.toUpperCase());
+}
+const DEFAULT_ELLIPSIS = '…';
+/**
+ * Truncates a string to fit within a specified pixel width or character count.
+ * If the string's width exceeds the maxWidth, it will be truncated. If the character
+ * count exceeds maxChars, it will also be truncated.
+ *
+ * The ellipsis can be placed at the start, middle, or end of the string.
+ */
+export function truncateText(text, { position = 'end', ellipsis = DEFAULT_ELLIPSIS, maxWidth, style, maxChars }) {
+    if (!text)
+        return '';
+    // no constraints, return original text
+    if (maxWidth === undefined && maxChars === undefined)
+        return text;
+    // apply maxChars constraint first (if provided)
+    let workingText = text;
+    if (maxChars !== undefined && text.length > maxChars) {
+        if (position === 'start') {
+            workingText = ellipsis + text.slice(-maxChars);
+        }
+        else if (position === 'middle') {
+            const half = Math.floor(maxChars / 2);
+            workingText = text.slice(0, half) + ellipsis + text.slice(-half);
+        }
+        else {
+            workingText = text.slice(0, maxChars) + ellipsis;
+        }
+    }
+    // apply maxWidth constraint (if provided)
+    if (maxWidth !== undefined) {
+        const fullWidth = getStringWidth(workingText, style);
+        // if width measurement fails or text fits, return current text
+        if (fullWidth === null || fullWidth <= maxWidth)
+            return workingText;
+        const ellipsisWidth = getStringWidth(ellipsis, style) ?? 0;
+        let availableWidth = maxWidth - ellipsisWidth;
+        if (position === 'start') {
+            let truncated = workingText.slice(ellipsis.length); // remove initial ellipsis if present
+            let truncatedWidth = getStringWidth(truncated, style);
+            while (truncatedWidth !== null && truncatedWidth > availableWidth && truncated.length > 0) {
+                truncated = truncated.slice(1);
+                truncatedWidth = getStringWidth(truncated, style);
+            }
+            return ellipsis + truncated;
+        }
+        else if (position === 'middle') {
+            const halfWidth = availableWidth / 2;
+            let left = '';
+            let right = '';
+            let bestLeft = '';
+            let bestRight = '';
+            for (let i = 0, j = workingText.length - 1; i < workingText.length && j >= 0; i++, j--) {
+                const leftTest = workingText.slice(0, i + 1);
+                const rightTest = workingText.slice(j);
+                const leftWidth = getStringWidth(leftTest, style);
+                const rightWidth = getStringWidth(rightTest, style);
+                if (leftWidth !== null && leftWidth <= halfWidth)
+                    left = leftTest;
+                if (rightWidth !== null && rightWidth <= halfWidth)
+                    right = rightTest;
+                const combinedWidth = getStringWidth(left + ellipsis + right, style);
+                if (combinedWidth !== null && combinedWidth <= maxWidth) {
+                    bestLeft = left; // longest valid left
+                    bestRight = right; // longest valid right
+                }
+                else {
+                    // we've exceed maxWidth, so break out
+                    break;
+                }
+            }
+            return bestLeft + ellipsis + bestRight;
+        }
+        else {
+            let truncated = workingText.slice(0, -ellipsis.length);
+            let truncatedWidth = getStringWidth(truncated + ellipsis, style);
+            while (truncatedWidth !== null && truncatedWidth > maxWidth && truncated.length > 0) {
+                truncated = truncated.slice(0, -1);
+                truncatedWidth = getStringWidth(truncated + ellipsis, style);
+            }
+            return truncated + ellipsis;
+        }
+    }
+    return workingText;
+}

package/dist/utils/ticks.d.ts

@@ -1,3 +1,9 @@
-export declare function getMajorTicks(start: Date, end: Date): import("d3-time").TimeInterval | null;
+import { type TimeInterval } from 'd3-time';
+import { type AnyScale } from './scales.svelte.js';
+export declare function getMajorTicks(start: Date, end: Date): TimeInterval | null;
 export declare function formatMajorTick(date: Date, rangeStart: Date, rangeEnd: Date): string;
-export declare function getMinorTicks(start: Date, end: Date): import("d3-time").TimeInterval | null;
+export declare function getMinorTicks(start: Date, end: Date): TimeInterval | null;
+export type TicksConfig = number | any[] | ((scale: AnyScale) => any[] | undefined) | {
+    interval: TimeInterval | null;
+} | null;
+export declare function resolveTickVals(scale: AnyScale, ticks?: TicksConfig, placement?: 'radius' | 'top' | 'bottom' | 'left' | 'right' | 'angle'): any[];

package/dist/utils/ticks.js

@@ -1,6 +1,7 @@
 import { timeYear, timeMonth, timeWeek, timeDay, timeHour, timeMinute, timeSecond, timeMillisecond, } from 'd3-time';
 import { format } from 'date-fns';
 import { formatDate, PeriodType, getDuration, fail } from '@layerstack/utils';
+import { isScaleBand } from './scales.svelte.js';
 // TODO: Use PeriodType along with Duration to format (and possibly select intervals)
 const majorTicks = [
     {
@@ -153,3 +154,30 @@ export function getMinorTicks(start, end) {
     }
     fail(`Unable to locate minor ticks for duration: ${duration}`);
 }
+export function resolveTickVals(scale, ticks, placement) {
+    if (Array.isArray(ticks))
+        return ticks;
+    if (typeof ticks === 'function')
+        return ticks(scale) ?? [];
+    if (isLiteralObject(ticks) && 'interval' in ticks) {
+        if (ticks.interval === null || !('ticks' in scale) || typeof scale.ticks !== 'function') {
+            return []; // Explicitly return empty array for null interval or invalid scale
+        }
+        return scale.ticks(ticks.interval);
+    }
+    if (isScaleBand(scale)) {
+        return ticks && typeof ticks === 'number'
+            ? scale.domain().filter((_, i) => i % ticks === 0)
+            : scale.domain();
+    }
+    if (scale.ticks && typeof scale.ticks === 'function') {
+        if (placement) {
+            return scale.ticks(ticks ?? (placement === 'left' || placement === 'right' ? 4 : undefined));
+        }
+        return scale.ticks(ticks);
+    }
+    return [];
+}
+function isLiteralObject(val) {
+    return val !== null && typeof val === 'object' && !Array.isArray(val);
+}

package/dist/utils/ticks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/ticks.test.js

@@ -0,0 +1,67 @@
+import { describe, it, expect, vi } from 'vitest';
+import { resolveTickVals } from './ticks.js';
+// Mock helpers
+const mockTicksFn = vi.fn();
+const mockDomain = vi.fn(() => ['a', 'b', 'c', 'd', 'e']);
+describe('resolveTickVals', () => {
+    it('returns array ticks directly', () => {
+        const ticks = [1, 2, 3];
+        const scale = { ticks: mockTicksFn };
+        expect(resolveTickVals(scale, ticks)).toEqual([1, 2, 3]);
+    });
+    it('calls function ticks with scale', () => {
+        const fnTicks = vi.fn(() => [4, 5, 6]);
+        const scale = { ticks: mockTicksFn };
+        expect(resolveTickVals(scale, fnTicks)).toEqual([4, 5, 6]);
+        expect(fnTicks).toHaveBeenCalledWith(scale);
+    });
+    it('uses interval when provided', () => {
+        const interval = { every: vi.fn() };
+        const ticksConfig = { interval };
+        const scale = { ticks: vi.fn(() => [7, 8, 9]) };
+        expect(resolveTickVals(scale, ticksConfig)).toEqual([7, 8, 9]);
+        expect(scale.ticks).toHaveBeenCalledWith(interval);
+    });
+    it('returns empty array if interval is null', () => {
+        const ticksConfig = { interval: null };
+        const scale = { ticks: mockTicksFn };
+        expect(resolveTickVals(scale, ticksConfig)).toEqual([]);
+    });
+    it('filters band scale domain with number ticks', () => {
+        const scale = { domain: mockDomain, bandwidth: vi.fn() };
+        expect(resolveTickVals(scale, 2)).toEqual(['a', 'c', 'e']);
+    });
+    it('returns full domain for band scale without ticks', () => {
+        const scale = { domain: mockDomain, bandwidth: vi.fn() };
+        expect(resolveTickVals(scale)).toEqual(['a', 'b', 'c', 'd', 'e']);
+    });
+    it('uses default 4 ticks for left placement', () => {
+        const scale = { ticks: vi.fn(() => [1, 2, 3, 4]) };
+        expect(resolveTickVals(scale, undefined, 'left')).toEqual([1, 2, 3, 4]);
+        expect(scale.ticks).toHaveBeenCalledWith(4);
+    });
+    it('uses default 4 ticks for right placement', () => {
+        const scale = { ticks: vi.fn(() => [1, 2, 3, 4]) };
+        expect(resolveTickVals(scale, undefined, 'right')).toEqual([1, 2, 3, 4]);
+        expect(scale.ticks).toHaveBeenCalledWith(4);
+    });
+    it('uses undefined for non-left/right placement', () => {
+        const scale = { ticks: vi.fn(() => [1, 2]) };
+        expect(resolveTickVals(scale, undefined, 'top')).toEqual([1, 2]);
+        expect(scale.ticks).toHaveBeenCalledWith(undefined);
+    });
+    it('passes number ticks to scale.ticks', () => {
+        const scale = { ticks: vi.fn(() => [10, 20]) };
+        expect(resolveTickVals(scale, 5)).toEqual([10, 20]);
+        expect(scale.ticks).toHaveBeenCalledWith(5);
+    });
+    it('returns empty array for scale without ticks', () => {
+        const scale = {};
+        expect(resolveTickVals(scale, 5)).toEqual([]);
+    });
+    it('handles null ticks with placement', () => {
+        const scale = { ticks: vi.fn(() => [1, 2, 3]) };
+        expect(resolveTickVals(scale, null, 'bottom')).toEqual([1, 2, 3]);
+        expect(scale.ticks).toHaveBeenCalledWith(undefined);
+    });
+});

package/dist/utils/types.d.ts

@@ -1,5 +1,86 @@
+import type { HierarchyNode } from 'd3-hierarchy';
+import type { AnyScale } from './scales.svelte.js';
+import type { SankeyGraph } from 'd3-sankey';
+import type { TransitionConfig } from 'svelte/transition';
 /**
  * Useful to workaround Svelte 3/4 markup type issues
  * TODO: Remove usage after migrating to Svelte 5
  */
 export declare function asAny(x: any): any;
+/**
+ * Constructs a new type by omitting properties from type
+ * 'T' that exist in type 'U'.
+ *
+ * @template T - The base object type from which properties will be omitted.
+ * @template U - The object type whose properties will be omitted from 'T'.
+ * @example
+ * type Result = Without<{ a: number; b: string; }, { b: string; }>;
+ * // Result type will be { a: number; }
+ */
+export type Without<T extends object, U extends object> = Omit<T, keyof U>;
+export type AxisKey = 'x' | 'y' | 'z' | 'r';
+export type Extents = {
+    [K in AxisKey]?: Array<number | string>;
+};
+export type Padding = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+export type Nice = boolean | number;
+export type BaseRange = number[] | string[] | ((args: {
+    width: number;
+    height: number;
+}) => number[] | string[]);
+export type YRangeWithScale<Scale extends AnyScale = AnyScale> = number[] | string[] | ((args: {
+    yScale: Scale;
+    width: number;
+    height: number;
+}) => number[] | string[]);
+export type XRangeWithScale<Scale extends AnyScale = AnyScale> = number[] | string[] | ((args: {
+    xScale: Scale;
+    width: number;
+    height: number;
+}) => number[] | string[]);
+export type FieldAccessors<T> = {
+    x?: (d: T) => number | string | (number | string)[];
+    y?: (d: T) => number | string | (number | string)[];
+    z?: (d: T) => number | string | (number | string)[];
+    r?: (d: T) => number | string | (number | string)[];
+};
+export type PaddingArray = [number, number] | number[] | undefined;
+export type DataType<T> = T[] | HierarchyNode<T> | SankeyGraph<any, any> | readonly T[];
+export type Transition = (node: Element, params?: any) => TransitionConfig;
+export type TransitionParams<T extends Transition> = Parameters<T>[1];
+/**
+ * Common style properties that apply to many components.
+ * Includes `fill`, `fillOpacity`, `stroke`, `strokeWidth`, and `opacity`.
+ */
+export type CommonStyleProps = {
+    /**
+     * The fill color of the element.
+     */
+    fill?: string;
+    /**
+     * The fill opacity of the element.
+     */
+    fillOpacity?: number;
+    /**
+     * The stroke color of the element.
+     */
+    stroke?: string;
+    /**
+     * The stroke width of the element.
+     */
+    strokeWidth?: number;
+    /**
+     * The opacity of the element. (0 to 1)
+     */
+    opacity?: number;
+};
+export type OnlyObjects<T> = T extends object ? T : never;
+export type Getter<T> = () => T;
+export type GetterValues<T> = {
+    [K in keyof T]: Getter<T[K]>;
+};