@fundar/data-chart-telling 0.0.64 → 1.1.0

package/dist/layout/scales/ScalesLayout.svelte

@@ -1,214 +1,283 @@
 <script lang="ts" generics="TData extends Record<string, unknown>">
-  import { AxisX, AxisY, GridX, GridY, usePlot } from 'svelteplot';
-  import { getConfiguration } from '../../configuration/config.svelte';
-  import { tickStep, ticksInRange, naturalTickCount } from './niceDomain';
-  import type { AxisValue, AxisBasedScalesConfig } from '../../types/layout/scales';
-
-  /**
-   * Axis ticks/titles and grid lines for plot kinds with an x/y axis pair
-   * (line/bar/heatmap/pyramid). Not used by `GeoPlot` (a map has no x/y axis
-   * pair). The scale itself is resolved by `buildScale` and applied via
-   * `BasePlotLayout`'s `<Plot x y>` — this only renders the cosmetics.
-   */
-  let {
-    data,
-    getX,
-    getY,
-    width,
-    height,
-    numericMargins,
-    scales,
-  }: {
-    data: TData[];
-    getX: (d: TData) => AxisValue;
-    getY: (d: TData) => AxisValue;
-    width: number;
-    height: number;
-    numericMargins: { top: number; right: number; bottom: number; left: number };
-    scales?: AxisBasedScalesConfig<TData>;
-  } = $props();
-
-  const cfg = $derived(getConfiguration());
-  const plot = usePlot();
-
-  const xValues = $derived(data.map(getX));
-  const yValues = $derived(data.map(getY));
-
-  /**
-   * `[min, max]` of a pinned `scale.domain` (if numeric), else the extent of
-   * `values`. Deliberately *not* the live, fully-resolved scale off
-   * `usePlot()` (e.g. `plot.scales.x.domain`), even though that would be
-   * more accurate for a bar's implicit zero baseline or a stacked series'
-   * cumulative total: reading it reactively here — inside a `$derived` that
-   * itself feeds back into `<AxisX>`'s rendered tick content, which
-   * `BasePlotLayout`'s own auto-margin sizing measures — closes a
-   * live-scale ⇄ rendered-axis feedback loop that was observed to perturb
-   * margin *settling* (a captured-and-frozen `bind:margins` value gained a
-   * stray extra `left` entry it wasn't tracking before). `edgeInclusiveTicks`
-   * instead sidesteps needing this axis's own real extent at all, by only
-   * running when the *opposite* axis's resolved type says it's safe to.
-   */
-  function axisExtent(scale: AxisBasedScalesConfig<TData>['x'], values: AxisValue[]): [number, number] | undefined {
-    const domainNumbers = scale?.domain?.filter((d): d is number => typeof d === 'number');
-    const source = domainNumbers && domainNumbers.length >= 2 ? domainNumbers : values.filter((v): v is number => typeof v === 'number');
-    if (source.length < 2) return undefined;
-    const lo = Math.min(...source);
-    const hi = Math.max(...source);
-    return hi > lo ? [lo, hi] : undefined;
-  }
-
-  /** Resolved scale types with their own discrete tick semantics — an axis paired with one of these plays the "index" role for the pair, so *this* axis is the plain magnitude/value one (see `autoTickCount`, `edgeInclusiveTicks`). */
-  const DISCRETE_SCALE_TYPES = new Set(['band', 'categorical', 'point', 'ordinal']);
-
-  /**
-   * Caps tick count to the axis's distinct value count, never above what
-   * fits the pixel span — meaningful for an index-like axis (don't show more
-   * ticks than there are actual data points), but not for a magnitude/value
-   * one, where "how many bars there are" has nothing to do with how many
-   * round numbers should label the axis (and can otherwise stop tick
-   * generation short of `nice`'s own widened domain edge — the same
-   * "opposite axis is discrete ⇒ this one's a value axis" signal
-   * `edgeInclusiveTicks` uses). Skipped once the caller sets tick density
-   * directly, or pins the domain.
-   */
-  function autoTickCount(
-    oppositeType: string | undefined,
-    scale: AxisBasedScalesConfig<TData>['x'],
-    values: AxisValue[],
-    span: number,
-    spacing: number,
-    min: number
-  ): number | undefined {
-    if (scale?.ticks != null || scale?.tickSpacing != null || scale?.interval != null || scale?.domain != null) return undefined;
-    if (oppositeType != null && DISCRETE_SCALE_TYPES.has(oppositeType)) return undefined;
-    const uniqueCount = new Set(values.map(String)).size;
-    const natural = naturalTickCount(span, spacing, min);
-    return uniqueCount >= 2 && uniqueCount < natural ? uniqueCount : undefined;
-  }
-
-  /** Forces a whole-unit tick interval on an integer domain that spans fewer integers than the pixel span would naturally want ticks for. */
-  function integerTickInterval(
-    scale: AxisBasedScalesConfig<TData>['x'],
-    values: AxisValue[],
-    span: number,
-    spacing: number,
-    min: number
-  ): number | undefined {
-    if (scale?.ticks != null || scale?.tickSpacing != null || scale?.interval != null) return undefined;
-    if (scale?.type != null && scale.type !== 'linear' && scale.type !== 'auto') return undefined;
-    const extent = axisExtent(scale, values);
-    if (!extent) return undefined;
-    const [lo, hi] = extent;
-    if (!Number.isInteger(lo) || !Number.isInteger(hi)) return undefined;
-    return hi - lo < naturalTickCount(span, spacing, min) ? 1 : undefined;
-  }
-
-  const xSpan = $derived(Math.max(0, width - numericMargins.left - numericMargins.right));
-  const ySpan = $derived(Math.max(0, height - numericMargins.top - numericMargins.bottom));
-
-  const xTickCount = $derived(autoTickCount(plot.scales.y.type, scales?.x, xValues, xSpan, 80, 3));
-  const yTickCount = $derived(autoTickCount(plot.scales.x.type, scales?.y, yValues, ySpan, 50, 2));
-
-  const xTickInterval = $derived(integerTickInterval(scales?.x, xValues, xSpan, 80, 3));
-  const yTickInterval = $derived(integerTickInterval(scales?.y, yValues, ySpan, 50, 2));
-
-  /**
-   * An axis's own natural "nice" ticks, plus the domain's exact endpoints
-   * whenever a natural tick doesn't already land on them — so the axis
-   * always labels the actual start/end of its real range, not just
-   * whichever round numbers happen to fall inside it (which, per
-   * `axisExtent`, may extend past the raw data — e.g. a bar's implicit zero
-   * baseline).
-   *
-   * Only meaningful for an axis that plays the "series ran from here to
-   * here" role — a time series' x, say — which is exactly the case where the
-   * *opposite* axis is itself continuous (both this codebase's line/scatter
-   * charts). When the opposite axis is discrete instead (a bar/pyramid's
-   * category axis), *this* axis is really the plain magnitude/value one —
-   * `84` isn't meaningfully "where the series ends" the way a last year is,
-   * so forcing it onto the axis just crowds a round `80`/`90` tick for no
-   * benefit. Skipped once the caller sets tick density/domain directly, same
-   * guard as `autoTickCount`, or the axis isn't a plain continuous numeric
-   * one (`integerTickInterval`'s domain check covers the same ground
-   * `axisExtent` needs here).
-   */
-  function edgeInclusiveTicks(
-    oppositeType: string | undefined,
-    scale: AxisBasedScalesConfig<TData>['x'],
-    values: AxisValue[],
-    span: number,
-    spacing: number,
-    min: number
-  ): number[] | undefined {
-    if (scale?.ticks != null || scale?.tickSpacing != null || scale?.interval != null || scale?.domain != null) return undefined;
-    if (oppositeType != null && DISCRETE_SCALE_TYPES.has(oppositeType)) return undefined;
-    if (scale?.type != null && scale.type !== 'linear' && scale.type !== 'auto') return undefined;
-    const extent = axisExtent(scale, values);
-    if (!extent) return undefined;
-    const [lo, hi] = extent;
-    const count = naturalTickCount(span, spacing, min);
-    const step = tickStep(lo, hi, count);
-    const base = ticksInRange(lo, hi, step);
-    const eps = step * 1e-6;
-    const withLo = base.length === 0 || base[0] - lo > eps ? [lo, ...base] : base;
-    return withLo.length === 0 || hi - withLo[withLo.length - 1] > eps ? [...withLo, hi] : withLo;
-  }
-
-  const xTicksExplicit = $derived(edgeInclusiveTicks(plot.scales.y.type, scales?.x, xValues, xSpan, 80, 3));
-
-  /** Vertical Y-axis title placement, when `scales.y.labelOrientation === 'vertical'`. */
-  const verticalYLabel = $derived.by(() => {
-    if (!scales?.y?.label || scales.y.labelOrientation !== 'vertical') return null;
-    const position = scales.y.labelPosition ?? 'middle';
-    const x = 14;
-    const top = numericMargins.top;
-    const bottom = height - numericMargins.bottom;
-    const y = position === 'top' ? top : (top + bottom) / 2;
-    return { text: scales.y.label, x, y, anchor: position === 'top' ? ('end' as const) : ('middle' as const) };
-  });
+	import { getContext, untrack } from 'svelte';
+	import type { Writable } from 'svelte/store';
+	import { AxisX, AxisY, GridX, GridY } from 'svelteplot';
+	import { usePlot } from '../plot/usePlot';
+	import { getConfiguration } from '../../configuration/config.svelte';
+	import { NiceTicks } from './NiceTicks';
+	import { EdgeTicks } from './EdgeTicks';
+	import { DISCRETE_SCALE_TYPES } from '../../types/layout/scales';
+	import type { AxisBasedScalesConfig } from '../../types/layout/scales';
+	import type { AxisValue } from '../../types/layout/mapping';
+
+	/** Axis ticks, titles and grid lines for the plot kinds with an x/y axis pair. */
+	let {
+		data,
+		getX,
+		getY,
+		width,
+		height,
+		numericMargins,
+		scales,
+		edgeDomains = undefined
+	}: {
+		data: TData[];
+		getX: (d: TData) => AxisValue;
+		getY: (d: TData) => AxisValue;
+		width: number;
+		height: number;
+		numericMargins: { top: number; right: number; bottom: number; left: number };
+		scales?: AxisBasedScalesConfig<TData>;
+		/**
+		 * Where to leave the domain an axis widens to when an edge tick's
+		 * `'extend'` resolved a collision (see `EdgeTicks`), for the plot to give its scale.
+		 */
+		edgeDomains?: Map<'x' | 'y', [number, number]>;
+	} = $props();
+
+	const cfg = $derived(getConfiguration());
+	const plot = usePlot().svelteplot;
+
+	const xValues = $derived(data.map(getX));
+	const yValues = $derived(data.map(getY));
+
+	/** `[min, max]` of a numeric pinned `scale.domain`, else of `values`. */
+	function axisExtent(
+		scale: AxisBasedScalesConfig<TData>['x'],
+		values: AxisValue[]
+	): [number, number] | undefined {
+		const domainNumbers = scale?.domain?.filter((d): d is number => typeof d === 'number');
+		const source =
+			domainNumbers && domainNumbers.length >= 2
+				? domainNumbers
+				: values.filter((v): v is number => typeof v === 'number');
+		if (source.length < 2) return undefined;
+		const lo = Math.min(...source);
+		const hi = Math.max(...source);
+		return hi > lo ? [lo, hi] : undefined;
+	}
+
+	/** An axis paired with a discrete scale plays the "index" role for the pair, so *this* axis is the plain magnitude/value one (see `autoTickCount`, `edgeTicksOf`). */
+	const isDiscreteType = (type: string) =>
+		(DISCRETE_SCALE_TYPES as readonly string[]).includes(type);
+
+	/**
+	 * Tick count for an index-like axis: its distinct values, at most what fits
+	 * the pixel span. Unset when the caller sets tick density or the domain.
+	 */
+	function autoTickCount(
+		oppositeType: string | undefined,
+		scale: AxisBasedScalesConfig<TData>['x'],
+		values: AxisValue[],
+		span: number,
+		spacing: number,
+		min: number
+	): number | undefined {
+		if (
+			scale?.ticks != null ||
+			scale?.tickSpacing != null ||
+			scale?.interval != null ||
+			scale?.domain != null
+		)
+			return undefined;
+		if (oppositeType != null && isDiscreteType(oppositeType)) return undefined;
+		const uniqueCount = new Set(values.map(String)).size;
+		const natural = NiceTicks.count(span, spacing, min);
+		return uniqueCount >= 2 && uniqueCount < natural ? uniqueCount : undefined;
+	}
+
+	/** Forces a whole-unit tick interval on an integer domain that spans fewer integers than the pixel span would naturally want ticks for. */
+	function integerTickInterval(
+		scale: AxisBasedScalesConfig<TData>['x'],
+		values: AxisValue[],
+		span: number,
+		spacing: number,
+		min: number
+	): number | undefined {
+		if (scale?.ticks != null || scale?.tickSpacing != null || scale?.interval != null)
+			return undefined;
+		if (scale?.type != null && scale.type !== 'linear' && scale.type !== 'auto') return undefined;
+		const extent = axisExtent(scale, values);
+		if (!extent) return undefined;
+		const [lo, hi] = extent;
+		if (!Number.isInteger(lo) || !Number.isInteger(hi)) return undefined;
+		return hi - lo < NiceTicks.count(span, spacing, min) ? 1 : undefined;
+	}
+
+	const xSpan = $derived(Math.max(0, width - numericMargins.left - numericMargins.right));
+	const ySpan = $derived(Math.max(0, height - numericMargins.top - numericMargins.bottom));
+
+	const xTickCount = $derived(
+		autoTickCount(plot.scales.y.type, scales?.x, xValues, xSpan, NiceTicks.SPACING.x, 3)
+	);
+	const yTickCount = $derived(
+		autoTickCount(plot.scales.x.type, scales?.y, yValues, ySpan, NiceTicks.SPACING.y, 2)
+	);
+
+	const xTickInterval = $derived(
+		integerTickInterval(scales?.x, xValues, xSpan, NiceTicks.SPACING.x, 3)
+	);
+	const yTickInterval = $derived(
+		integerTickInterval(scales?.y, yValues, ySpan, NiceTicks.SPACING.y, 2)
+	);
+
+	/**
+	 * A continuous axis' nice ticks plus the data's first and last values (see
+	 * {@link EdgeTicks}), when its other axis is continuous too and the author
+	 * left its density and domain to the plot. Unset otherwise.
+	 */
+	function edgeTicksOf(
+		axis: 'x' | 'y',
+		type: string | undefined,
+		oppositeType: string | undefined,
+		scale: AxisBasedScalesConfig<TData>['x'],
+		values: AxisValue[],
+		span: number,
+		min: number
+	) {
+		if (
+			scale?.ticks != null ||
+			scale?.tickSpacing != null ||
+			scale?.interval != null ||
+			scale?.domain != null
+		)
+			return undefined;
+		if (type != null && isDiscreteType(type)) return undefined;
+		if (oppositeType != null && isDiscreteType(oppositeType)) return undefined;
+		if (scale?.type != null && scale.type !== 'linear' && scale.type !== 'auto') return undefined;
+		const present = values.filter((v) => v != null);
+		if (!present.every((v) => typeof v === 'number')) return undefined;
+		return EdgeTicks.build({
+			axis,
+			values: (present as number[]).filter(Number.isFinite),
+			span,
+			spacing: NiceTicks.SPACING[axis],
+			min,
+			fontSize: cfg.axis.fontSize,
+			options: EdgeTicks.resolve(scale?.edgeTicks, cfg.axis.edgeTicks[axis])
+		});
+	}
+
+	const xEdgeTicks = $derived(
+		edgeTicksOf('x', plot.scales.x.type, plot.scales.y.type, scales?.x, xValues, xSpan, 3)
+	);
+	const yEdgeTicks = $derived(
+		edgeTicksOf('y', plot.scales.y.type, plot.scales.x.type, scales?.y, yValues, ySpan, 2)
+	);
+
+	// Hands the plot the domain an axis widens to, only when it changes.
+	$effect(() => {
+		const next = { x: xEdgeTicks?.domain, y: yEdgeTicks?.domain };
+		untrack(() => {
+			for (const axis of ['x', 'y'] as const) {
+				const domain = next[axis];
+				const current = edgeDomains?.get(axis);
+				if (domain?.[0] === current?.[0] && domain?.[1] === current?.[1]) continue;
+				if (domain) edgeDomains?.set(axis, domain);
+				else edgeDomains?.delete(axis);
+			}
+		});
+	});
+
+	const yTitleFontSize = $derived(scales?.y?.titleFontSize ?? cfg.axis.titleFontSize);
+
+	/**
+	 * Vertical Y-axis title placement, when `scales.y.labelOrientation === 'vertical'`:
+	 * `scales.y.label`, else the channel name svelteplot would title the axis with.
+	 */
+	const verticalYLabel = $derived.by(() => {
+		if (scales?.y?.labelOrientation !== 'vertical' || scales.y.label === false) return null;
+		const text = scales.y.label || plot.scales.y.autoTitle;
+		if (!text) return null;
+		const position = scales.y.labelPosition ?? 'middle';
+		const x = yTitleFontSize;
+		const top = numericMargins.top;
+		const bottom = height - numericMargins.bottom;
+		const y = position === 'top' ? top : (top + bottom) / 2;
+		return { text, x, y, anchor: position === 'top' ? ('end' as const) : ('middle' as const) };
+	});
+
+	// svelteplot sizes an `'auto'` left margin to the widest need its marks
+	// register here; a vertical title asks for the y axis' own plus its line.
+	const { autoMarginLeft } = getContext<{ autoMarginLeft: Writable<Map<string, number>> }>(
+		'svelteplot/autoMargins'
+	);
+	const marginId = `dct-vertical-y-label-${Math.random().toString(36).slice(2)}`;
+	const VERTICAL_LABEL_GAP = 6;
+	const axisMarginLeft = $derived(
+		Math.max(0, ...[...$autoMarginLeft].filter(([id]) => id !== marginId).map(([, v]) => v))
+	);
+	$effect(() => {
+		const wanted =
+			verticalYLabel && (scales?.y?.axisDisplay ?? 'visible') === 'visible'
+				? axisMarginLeft + Math.ceil(yTitleFontSize * 1.25) + VERTICAL_LABEL_GAP
+				: undefined;
+		untrack(() => {
+			if (wanted === undefined) $autoMarginLeft.delete(marginId);
+			else if ($autoMarginLeft.get(marginId) !== wanted) $autoMarginLeft.set(marginId, wanted);
+		});
+	});
+	$effect(() => () => {
+		$autoMarginLeft.delete(marginId);
+	});
 </script>
 
-<AxisX
-  ticks={xTicksExplicit}
-  tickCount={xTickCount}
-  interval={xTickInterval}
-  tickSize={scales?.x?.tickSize ?? cfg.axis.xTickSize}
-  tickPadding={scales?.x?.tickPadding ?? cfg.axis.xTickPadding}
-  tickFontSize={cfg.axis.fontSize}
-  titleFontSize={scales?.x?.titleFontSize ?? cfg.axis.titleFontSize}
-/>
-<AxisY
-  tickCount={yTickCount}
-  interval={yTickInterval}
-  tickSize={scales?.y?.tickSize ?? cfg.axis.yTickSize}
-  tickPadding={scales?.y?.tickPadding ?? cfg.axis.yTickPadding}
-  tickFontSize={cfg.axis.fontSize}
-  titleFontSize={scales?.y?.titleFontSize ?? cfg.axis.titleFontSize}
-/>
-{#if verticalYLabel}
-  <text
-    x={verticalYLabel.x}
-    y={verticalYLabel.y}
-    transform="rotate(-90, {verticalYLabel.x}, {verticalYLabel.y})"
-    text-anchor={verticalYLabel.anchor}
-    font-size={scales?.y?.titleFontSize ?? cfg.axis.titleFontSize}
-    fill={cfg.axis.color}
-    opacity="0.8"
-  >{verticalYLabel.text}</text>
+{#snippet axisX()}
+	<AxisX
+		ticks={xEdgeTicks?.ticks}
+		tickCount={xTickCount}
+		interval={xTickInterval}
+		tickSize={scales?.x?.tickSize ?? cfg.axis.xTickSize}
+		tickPadding={scales?.x?.tickPadding ?? cfg.axis.xTickPadding}
+		tickFontSize={cfg.axis.fontSize}
+		titleFontSize={scales?.x?.titleFontSize ?? cfg.axis.titleFontSize}
+	/>
+{/snippet}
+{#if scales?.x?.axisDisplay === 'hidden'}
+	<g style:visibility="hidden">{@render axisX()}</g>
+{:else if scales?.x?.axisDisplay !== 'none'}
+	{@render axisX()}
+{/if}
+{#snippet axisY()}
+	<AxisY
+		ticks={yEdgeTicks?.ticks}
+		tickCount={yTickCount}
+		interval={yTickInterval}
+		tickSize={scales?.y?.tickSize ?? cfg.axis.yTickSize}
+		tickPadding={scales?.y?.tickPadding ?? cfg.axis.yTickPadding}
+		tickFontSize={cfg.axis.fontSize}
+		titleFontSize={scales?.y?.titleFontSize ?? cfg.axis.titleFontSize}
+	/>
+{/snippet}
+{#if scales?.y?.axisDisplay === 'hidden'}
+	<g style:visibility="hidden">{@render axisY()}</g>
+{:else if scales?.y?.axisDisplay !== 'none'}
+	{@render axisY()}
+{/if}
+{#if verticalYLabel && (scales?.y?.axisDisplay ?? 'visible') === 'visible'}
+	<text
+		x={verticalYLabel.x}
+		y={verticalYLabel.y}
+		transform="rotate(-90, {verticalYLabel.x}, {verticalYLabel.y})"
+		text-anchor={verticalYLabel.anchor}
+		font-size={yTitleFontSize}
+		fill={cfg.axis.color}
+		opacity="0.8">{verticalYLabel.text}</text
+	>
 {/if}
 {#if scales?.x?.grid}
-  <GridX
-    stroke={typeof scales.x.grid === 'object' ? scales.x.grid.stroke : undefined}
-    strokeWidth={typeof scales.x.grid === 'object' ? scales.x.grid.strokeWidth : undefined}
-    strokeOpacity={typeof scales.x.grid === 'object' ? scales.x.grid.strokeOpacity : undefined}
-    strokeDasharray={typeof scales.x.grid === 'object' ? scales.x.grid.strokeDasharray : undefined}
-  />
+	<GridX
+		stroke={typeof scales.x.grid === 'object' ? scales.x.grid.stroke : undefined}
+		strokeWidth={typeof scales.x.grid === 'object' ? scales.x.grid.strokeWidth : undefined}
+		strokeOpacity={typeof scales.x.grid === 'object' ? scales.x.grid.strokeOpacity : undefined}
+		strokeDasharray={typeof scales.x.grid === 'object' ? scales.x.grid.strokeDasharray : undefined}
+	/>
 {/if}
 {#if scales?.y?.grid}
-  <GridY
-    stroke={typeof scales.y.grid === 'object' ? scales.y.grid.stroke : undefined}
-    strokeWidth={typeof scales.y.grid === 'object' ? scales.y.grid.strokeWidth : undefined}
-    strokeOpacity={typeof scales.y.grid === 'object' ? scales.y.grid.strokeOpacity : undefined}
-    strokeDasharray={typeof scales.y.grid === 'object' ? scales.y.grid.strokeDasharray : undefined}
-  />
+	<GridY
+		stroke={typeof scales.y.grid === 'object' ? scales.y.grid.stroke : undefined}
+		strokeWidth={typeof scales.y.grid === 'object' ? scales.y.grid.strokeWidth : undefined}
+		strokeOpacity={typeof scales.y.grid === 'object' ? scales.y.grid.strokeOpacity : undefined}
+		strokeDasharray={typeof scales.y.grid === 'object' ? scales.y.grid.strokeDasharray : undefined}
+	/>
 {/if}

package/dist/layout/scales/ScalesLayout.svelte.d.ts

@@ -1,4 +1,5 @@
-import type { AxisValue, AxisBasedScalesConfig } from '../../types/layout/scales';
+import type { AxisBasedScalesConfig } from '../../types/layout/scales';
+import type { AxisValue } from '../../types/layout/mapping';
 declare function $$render<TData extends Record<string, unknown>>(): {
     props: {
         data: TData[];
@@ -13,6 +14,11 @@ declare function $$render<TData extends Record<string, unknown>>(): {
             left: number;
         };
         scales?: AxisBasedScalesConfig<TData>;
+        /**
+         * Where to leave the domain an axis widens to when an edge tick's
+         * `'extend'` resolved a collision (see `EdgeTicks`), for the plot to give its scale.
+         */
+        edgeDomains?: Map<"x" | "y", [number, number]>;
     };
     exports: {};
     bindings: "";

package/dist/layout/scales/SveltePlotScale.d.ts

@@ -0,0 +1,15 @@
+import type { AxisScale } from '../../types/layout/scales';
+import type { AxisValue } from '../../types/layout/mapping';
+/** An {@link AxisScale} turned into the options svelteplot's `<Plot x>`/`<Plot y>` accepts. */
+export declare class SveltePlotScale {
+    #private;
+    /** Scale types the default `nice` applies to - every other type has its own tick semantics (or isn't numeric at all). */
+    static readonly CONTINUOUS_NUMERIC_TYPES: ReadonlySet<string>;
+    /**
+     * The scale without what the package handles itself - `grid`, `axisDisplay`
+     * and a vertical `label`, which `ScalesLayout` draws, and `niceTolerance`,
+     * which the "scales" phase applies - with a custom `sort` resolved into a
+     * `domain`, and `nice: true` on an unpinned numeric axis.
+     */
+    static build<TData>(scale: AxisScale<TData> | undefined, rows: TData[], getAxisValue: (d: TData) => AxisValue): AxisScale<TData> | undefined;
+}

package/dist/layout/scales/SveltePlotScale.js

@@ -0,0 +1,79 @@
+import { SvelteSet } from 'svelte/reactivity';
+/** An {@link AxisScale} turned into the options svelteplot's `<Plot x>`/`<Plot y>` accepts. */
+export class SveltePlotScale {
+    /** Scale types the default `nice` applies to - every other type has its own tick semantics (or isn't numeric at all). */
+    static CONTINUOUS_NUMERIC_TYPES = new Set([
+        'auto',
+        'linear',
+        'pow',
+        'sqrt',
+        'log',
+        'symlog'
+    ]);
+    /**
+     * The scale without what the package handles itself - `grid`, `axisDisplay`
+     * and a vertical `label`, which `ScalesLayout` draws, and `niceTolerance`,
+     * which the "scales" phase applies - with a custom `sort` resolved into a
+     * `domain`, and `nice: true` on an unpinned numeric axis.
+     */
+    static build(scale, rows, getAxisValue) {
+        const sorted = SveltePlotScale.#sorted(scale, rows, getAxisValue);
+        const wantsNice = scale?.domain == null &&
+            scale?.ticks == null &&
+            scale?.nice == null &&
+            (scale?.type == null || SveltePlotScale.CONTINUOUS_NUMERIC_TYPES.has(scale.type)) &&
+            SveltePlotScale.#isNumeric(rows, getAxisValue);
+        const removesAxis = scale?.axisDisplay === 'none';
+        if (!sorted && !wantsNice && !removesAxis)
+            return sorted;
+        const out = { ...sorted };
+        delete out.grid;
+        delete out.axisDisplay;
+        delete out.niceTolerance;
+        if (removesAxis)
+            out.axis = false;
+        if (scale?.labelOrientation === 'vertical')
+            out.label = false;
+        if (wantsNice)
+            out.nice = true;
+        return out;
+    }
+    /** svelteplot's `sort` option only does a fixed ascending sort; a custom `scale.sort` comparator is resolved into an explicit `domain` instead, which svelteplot honors as-is. */
+    static #sorted(scale, rows, getAxisValue) {
+        const sort = scale?.sort;
+        if (!sort || scale?.domain)
+            return scale;
+        const reps = SveltePlotScale.#uniqueRows(rows, getAxisValue);
+        if (reps.length === 0 || !reps.every((r) => typeof getAxisValue(r) === 'string'))
+            return scale;
+        const domain = [...reps].sort(sort).map(getAxisValue);
+        return { ...scale, domain };
+    }
+    /** One representative row per unique axis value (first occurrence in `rows`). */
+    static #uniqueRows(rows, getAxisValue) {
+        const seen = new SvelteSet();
+        const out = [];
+        for (const row of rows) {
+            const v = getAxisValue(row);
+            if (seen.has(v))
+                continue;
+            seen.add(v);
+            out.push(row);
+        }
+        return out;
+    }
+    /** Whether the axis' values are numeric; `nice` on a categorical axis would make svelteplot treat it as linear. */
+    static #isNumeric(rows, getAxisValue) {
+        let numericSeen = 0;
+        for (const row of rows) {
+            const v = getAxisValue(row);
+            if (v == null)
+                continue;
+            if (typeof v !== 'number')
+                return false;
+            if (++numericSeen >= 2)
+                return true;
+        }
+        return numericSeen > 0;
+    }
+}