@fundar/data-chart-telling 0.0.64 → 1.0.0

package/dist/layout/scales/ScalesLayout.svelte

@@ -1,214 +1,249 @@
 <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 { tickStep, ticksInRange, naturalTickCount } from './niceDomain';
+	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
+	}: {
+		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().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`, `edgeInclusiveTicks`). */
+	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 = 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));
+
+	/**
+	 * A continuous axis' nice ticks plus its domain's endpoints, when the
+	 * opposite axis is continuous too - at least a whole unit apart when every
+	 * value is a whole number. Unset when the caller sets tick density
+	 * or the domain.
+	 */
+	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 && isDiscreteType(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);
+		// Whole-number values (years, counts) never get ticks between them.
+		const integers = values.every((v) => typeof v !== 'number' || Number.isInteger(v));
+		const step = integers ? Math.max(1, tickStep(lo, hi, count)) : 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)
+	);
+
+	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={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}
+	/>
+{/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
+		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[];

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

@@ -1,25 +1,8 @@
-import type { AxisValue, AxisScale } from '../../types/layout/scales';
+import type { AxisScale } from '../../types/layout/scales';
+import type { AxisValue } from '../../types/layout/mapping';
 /**
- * Resolves an author-facing {@link AxisScale} into what svelteplot's
- * `<Plot x>`/`<Plot y>` accepts — strips `grid`/`seriesLayout`/
- * `seriesPadding`/a vertical `label`, since `ScalesLayout` renders those
- * itself. Also defaults `nice: true` whenever the caller hasn't pinned a
- * `domain`/`ticks`/`nice`/non-numeric `type` of their own and the axis's own
- * values are plainly numeric ({@link isNumericAxis}), so an unpinned
- * continuous axis rounds its domain outward to whole tick steps instead of
- * stopping exactly at the data's own min/max.
- *
- * Deliberately *not* our own `[min, max]` padding: svelteplot computes the
- * real domain from every mark's own channels — e.g. a bar's implicit zero
- * baseline, or a stacked series' cumulative total — not just this axis's raw
- * per-row values, which is all this function has to work with. `nice`'s
- * domain-widening runs *after* that real domain is resolved, inside
- * svelteplot itself, so it stays correct for every plot kind for free — at
- * the cost of only widening up to the nearest round tick step, which can
- * still land exactly on the data's own min/max rather than strictly beyond
- * it (e.g. a value of exactly `52` needs no widening to reach the nice tick
- * `52`). Recomputing the domain ourselves to close that gap would need each
- * axis's true rendered extent (baseline/stack included), which only the
- * calling plot kind knows — not attempted here.
+ * An {@link AxisScale} as svelteplot's `<Plot x>`/`<Plot y>` accepts it: without
+ * `grid`, `axisDisplay` and a vertical `label`, which `ScalesLayout` draws, and
+ * with `nice: true` on an unpinned numeric axis.
  */
 export declare function buildScale<TData>(scale: AxisScale<TData> | undefined, rows: TData[], getAxisValue: (d: TData) => AxisValue): AxisScale<TData> | undefined;

package/dist/layout/scales/buildScale.js

@@ -23,16 +23,9 @@ function sortedScale(scale, rows, getAxisValue) {
     const domain = [...reps].sort(sort).map(getAxisValue);
     return { ...scale, domain };
 }
-/** Scale types {@link buildScale}'s default `nice` only applies to — every other type has its own tick semantics (or isn't numeric at all). */
+/** Scale types {@link buildScale}'s default `nice` only applies to - every other type has its own tick semantics (or isn't numeric at all). */
 const CONTINUOUS_NUMERIC_TYPES = new Set(['auto', 'linear', 'pow', 'sqrt', 'log', 'symlog']);
-/**
- * Whether this axis's own values are plainly numeric — required before
- * defaulting `nice: true`. Not just an optimization: svelteplot's own type
- * *inference* treats a `nice` option as a hint to resolve the scale as
- * `'linear'` (see its `autoScales.js`), so setting it on a scale whose real
- * values are strings (a bar/pyramid's category axis) would force a linear
- * scale onto categorical data and break the mark entirely.
- */
+/** Whether the axis' values are numeric; `nice` on a categorical axis would make svelteplot treat it as linear. */
 function isNumericAxis(rows, getAxisValue) {
     let numericSeen = 0;
     for (const row of rows) {
@@ -47,27 +40,9 @@ function isNumericAxis(rows, getAxisValue) {
     return numericSeen > 0;
 }
 /**
- * Resolves an author-facing {@link AxisScale} into what svelteplot's
- * `<Plot x>`/`<Plot y>` accepts — strips `grid`/`seriesLayout`/
- * `seriesPadding`/a vertical `label`, since `ScalesLayout` renders those
- * itself. Also defaults `nice: true` whenever the caller hasn't pinned a
- * `domain`/`ticks`/`nice`/non-numeric `type` of their own and the axis's own
- * values are plainly numeric ({@link isNumericAxis}), so an unpinned
- * continuous axis rounds its domain outward to whole tick steps instead of
- * stopping exactly at the data's own min/max.
- *
- * Deliberately *not* our own `[min, max]` padding: svelteplot computes the
- * real domain from every mark's own channels — e.g. a bar's implicit zero
- * baseline, or a stacked series' cumulative total — not just this axis's raw
- * per-row values, which is all this function has to work with. `nice`'s
- * domain-widening runs *after* that real domain is resolved, inside
- * svelteplot itself, so it stays correct for every plot kind for free — at
- * the cost of only widening up to the nearest round tick step, which can
- * still land exactly on the data's own min/max rather than strictly beyond
- * it (e.g. a value of exactly `52` needs no widening to reach the nice tick
- * `52`). Recomputing the domain ourselves to close that gap would need each
- * axis's true rendered extent (baseline/stack included), which only the
- * calling plot kind knows — not attempted here.
+ * An {@link AxisScale} as svelteplot's `<Plot x>`/`<Plot y>` accepts it: without
+ * `grid`, `axisDisplay` and a vertical `label`, which `ScalesLayout` draws, and
+ * with `nice: true` on an unpinned numeric axis.
  */
 export function buildScale(scale, rows, getAxisValue) {
     const sorted = sortedScale(scale, rows, getAxisValue);
@@ -76,14 +51,16 @@ export function buildScale(scale, rows, getAxisValue) {
         scale?.nice == null &&
         (scale?.type == null || CONTINUOUS_NUMERIC_TYPES.has(scale.type)) &&
         isNumericAxis(rows, getAxisValue);
-    if (!sorted && !wantsNice)
+    const removesAxis = scale?.axisDisplay === 'none';
+    if (!sorted && !wantsNice && !removesAxis)
         return sorted;
     const out = { ...sorted };
     delete out.grid;
-    delete out.seriesLayout;
-    delete out.seriesPadding;
+    delete out.axisDisplay;
+    if (removesAxis)
+        out.axis = false;
     if (scale?.labelOrientation === 'vertical')
-        delete out.label;
+        out.label = false;
     if (wantsNice)
         out.nice = true;
     return out;

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

@@ -2,10 +2,10 @@
 export declare function tickStep(start: number, stop: number, count: number): number;
 /** Multiples of `step` covering `[start, stop]`, inclusive of either endpoint when it lands exactly on one. */
 export declare function ticksInRange(start: number, stop: number, step: number): number[];
-/** Ticks-per-axis heuristic — used by `ScalesLayout` to pick a target count from an axis's actual pixel span. */
+/** Ticks-per-axis heuristic - used by `ScalesLayout` to pick a target count from an axis's actual pixel span. */
 export declare function naturalTickCount(span: number, spacing: number, min: number): number;
 /**
- * Widens `[lo, hi]` outward to the nearest `count`-ish "nice" step —
+ * Widens `[lo, hi]` outward to the nearest `count`-ish "nice" step -
  * equivalent to d3's own `scale.nice(count)`, except a value within
  * `epsilonFraction × step` of a step boundary is treated as already sitting
  * on it, rather than needing a full extra step to clear it.
@@ -17,7 +17,7 @@ export declare function naturalTickCount(span: number, spacing: number, min: num
  * to a whole" data, e.g. percentages of a total) still fails `hi <= step*N`
  * and gets rounded up a full step further than the data actually warrants
  * (`100` → `110`, not just a hair past `100`). `epsilonFraction` defaults to
- * 1% of the step — small enough to only catch rounding/summation noise, not
+ * 1% of the step - small enough to only catch rounding/summation noise, not
  * data that's genuinely meaningfully past the boundary.
  */
 export declare function niceDomain(lo: number, hi: number, count?: number, epsilonFraction?: number): [number, number];