@opendata-ai/openchart-engine 8.0.0-rc.9 → 8.1.0

package/src/layout/axes/rotation.ts

@@ -1,152 +0,0 @@
-/**
- * Auto-rotation and thinning policy for band-scale x-axis tick labels.
- *
- * Band categories are data: every bar should keep its label. The policy
- * steepens the label angle until everything fits — flat, then -45°, then -90°
- * (vertical) — and only thins (uniform every-Nth) when even the steepest
- * usable angle cannot fit every label, which takes dozens of categories at
- * tiny steps.
- *
- * The collision geometry differs by orientation, and getting it right is what
- * makes thinning almost never necessary:
- *
- * - FLAT labels share a baseline, so adjacent labels collide when the widest
- *   label's width exceeds the anchor spacing.
- * - ROTATED labels are PARALLEL RIBBONS: every label leans at the same angle
- *   from its own anchor, so adjacent labels are parallel segments. They clear
- *   each other when EITHER the perpendicular separation between the ribbons
- *   (`spacing * |sin θ|`) exceeds one line height, OR the offset along the
- *   text direction (`spacing * |cos θ|`) exceeds the label length — finite
- *   segments slide past each other end-to-end at shallow angles. Earlier
- *   revisions modeled rotated labels as 1-D horizontal spans, which reported
- *   phantom collisions for long labels (dropping "2025" beside
- *   "2026 (to wk 17)") even though the rendered diagonals never touch.
- *
- * The layout planner and computeAxes must agree on these decisions: the
- * planner reserves the bottom margin for the rotated label footprint, and
- * computeAxes emits the same angle. Sharing this module keeps the reserved
- * space matched to the rendered labels (a mismatch spilled rotated ticks into
- * the source line).
- */
-
-import { TICK_LINE_HEIGHT_FACTOR, X_AXIS_ROTATED_EXTENT_CAP } from '@opendata-ai/openchart-core';
-
-/** Band fraction above which flat labels are considered too wide to fit. */
-const BAND_FIT_FRACTION = 0.85;
-
-/** Diagonal angle tried first when flat labels don't fit. */
-const AUTO_ROTATE_ANGLE = -45;
-
-/** Vertical angle used when diagonal ribbons would touch. */
-const STEEP_ROTATE_ANGLE = -90;
-
-/** Minimum visible gap between adjacent label ribbons, in px. */
-const LABEL_GAP = 4;
-
-/**
- * Perpendicular separation between adjacent rotated label ribbons.
- * Labels anchor at points `spacing` apart; leaning at `angleDeg` makes them
- * parallel lines whose perpendicular distance is `spacing * |sin(angle)|`.
- */
-function ribbonSeparation(spacing: number, angleDeg: number): number {
-  return spacing * Math.abs(Math.sin((angleDeg * Math.PI) / 180));
-}
-
-/**
- * Offset between adjacent labels measured along the text direction.
- * Finite labels clear each other end-to-end when this exceeds the label
- * length, even if the ribbons are closer than a line height — the escape
- * route that matters at shallow angles.
- */
-function alongTextClearance(spacing: number, angleDeg: number): number {
-  return spacing * Math.abs(Math.cos((angleDeg * Math.PI) / 180));
-}
-
-/** Whether every label fits at the given rotation without touching. */
-function rotatedLabelsFit(
-  spacing: number,
-  angleDeg: number,
-  fontSize: number,
-  maxLabelWidth: number,
-): boolean {
-  return (
-    ribbonSeparation(spacing, angleDeg) >= fontSize * TICK_LINE_HEIGHT_FACTOR + LABEL_GAP ||
-    alongTextClearance(spacing, angleDeg) >= maxLabelWidth + LABEL_GAP
-  );
-}
-
-/**
- * Decide the effective x tick angle for a band scale: the shallowest angle in
- * the ladder (flat → -45° → -90°) at which adjacent labels don't touch.
- *
- * The flat trigger compares the widest label against the bandwidth (does the
- * flat label fit its band?) — the long-standing rule, kept for stability.
- * The rotated steps use the parallel-ribbon fit test above.
- *
- * -90° projects the full label length vertically, so labels longer than the
- * reserved-extent cap would clip into the source line. For those the ladder
- * stays at -45° (smaller vertical footprint) and lets the stride safety net
- * thin the ribbons instead.
- *
- * @param explicitAngle - User-specified labelAngle (wins if defined).
- * @param maxLabelWidth - Widest tick label width in pixels.
- * @param bandwidth - Band width in pixels (excludes inner padding).
- * @param labelCount - Number of category labels (rotation needs >= 2).
- * @param spacing - Distance between the closest adjacent DRAWN tick anchors.
- *   This is the band step when every category gets a tick, but a multiple of
- *   it when an explicit tickCount capped the tick set upstream.
- * @param fontSize - Tick label font size (ribbon thickness term).
- * @returns The explicit angle, `-45`, `-90`, or `undefined` (no rotation).
- */
-export function resolveBandTickAngle(
-  explicitAngle: number | undefined,
-  maxLabelWidth: number,
-  bandwidth: number,
-  labelCount: number,
-  spacing: number,
-  fontSize: number,
-): number | undefined {
-  if (explicitAngle !== undefined) return explicitAngle;
-  if (labelCount < 2) return undefined;
-  if (maxLabelWidth <= bandwidth * BAND_FIT_FRACTION) return undefined;
-  if (rotatedLabelsFit(spacing, AUTO_ROTATE_ANGLE, fontSize, maxLabelWidth)) {
-    return AUTO_ROTATE_ANGLE;
-  }
-  return maxLabelWidth <= X_AXIS_ROTATED_EXTENT_CAP ? STEEP_ROTATE_ANGLE : AUTO_ROTATE_ANGLE;
-}
-
-/**
- * Uniform every-Nth retention stride for band tick labels — the safety net
- * for when even the resolved angle cannot fit every label (dozens of
- * categories at tiny steps, an explicit shallow labelAngle on a crowded axis,
- * or labels too long for the -90° escalation). Returns 1 (keep every label)
- * whenever labels fit.
- *
- * Callers keep indices counting back from the LAST label
- * (`(lastIdx - i) % stride === 0`) so the most recent category — usually the
- * most editorially important — is always labeled.
- *
- * Flat labels collide along their shared baseline, so the stride is driven by
- * the widest label's width. Rotated labels escape by either route — ribbon
- * separation or along-text clearance — and both scale linearly with the
- * stride, so the cheaper one wins.
- */
-export function bandLabelStride(
-  maxLabelWidth: number,
-  angleDeg: number | undefined,
-  fontSize: number,
-  spacing: number,
-): number {
-  if (spacing <= 0) return 1;
-  if (angleDeg === undefined || angleDeg === 0) {
-    return Math.max(1, Math.ceil((maxLabelWidth + LABEL_GAP) / spacing));
-  }
-  const separation = ribbonSeparation(spacing, angleDeg);
-  const clearance = alongTextClearance(spacing, angleDeg);
-  const required = fontSize * TICK_LINE_HEIGHT_FACTOR + LABEL_GAP;
-  const byRibbon = separation > 0 ? Math.ceil(required / separation) : Number.POSITIVE_INFINITY;
-  const byLength =
-    clearance > 0 ? Math.ceil((maxLabelWidth + LABEL_GAP) / clearance) : Number.POSITIVE_INFINITY;
-  const stride = Math.min(byRibbon, byLength);
-  return Number.isFinite(stride) ? Math.max(1, stride) : 1;
-}

package/src/layout/axes/thinning.ts

@@ -1,98 +0,0 @@
-/**
- * Tick label overlap detection and density thinning.
- *
- * Horizontal orientation (x-axis): checks label width against adjacent
- * positions. Vertical orientation (y-axis): checks font-based label height
- * against adjacent positions, ignoring text width so wide numeric labels
- * don't trigger aggressive thinning.
- */
-
-import type { AxisTick, MeasureTextFn } from '@opendata-ai/openchart-core';
-import { estimateTextWidth } from '@opendata-ai/openchart-core';
-
-/**
- * Minimum gap between adjacent tick labels as a multiple of font size.
- * At the default 11px axis font, this yields ~5-6px of breathing room.
- * Reduced from 1.0 to 0.5 to prevent over-aggressive thinning on charts
- * with a small number of categories that clearly have room for all labels.
- */
-const MIN_TICK_GAP_FACTOR = 0.5;
-
-/** Always show at least this many ticks, even if they overlap. */
-const MIN_TICK_COUNT = 2;
-
-/** Measure a single label's width using real measurement or heuristic fallback. */
-export function measureLabel(
-  text: string,
-  fontSize: number,
-  fontWeight: number,
-  measureText?: MeasureTextFn,
-): number {
-  return measureText
-    ? measureText(text, fontSize, fontWeight).width
-    : estimateTextWidth(text, fontSize, fontWeight);
-}
-
-/** Check whether any adjacent tick labels overlap along the axis direction. */
-export function ticksOverlap(
-  ticks: AxisTick[],
-  fontSize: number,
-  fontWeight: number,
-  measureText?: MeasureTextFn,
-  orientation: 'horizontal' | 'vertical' = 'horizontal',
-): boolean {
-  if (ticks.length < 2) return false;
-  const minGap = fontSize * MIN_TICK_GAP_FACTOR;
-
-  if (orientation === 'vertical') {
-    // Y-axis: labels are stacked vertically. Check if vertical extent
-    // (based on font height) overlaps between adjacent ticks.
-    // Positions decrease going up in SVG coords, so sort ascending.
-    const sorted = [...ticks].sort((a, b) => a.position - b.position);
-    const labelHeight = fontSize * 1.2; // lineHeight
-    for (let i = 0; i < sorted.length - 1; i++) {
-      const aBottom = sorted[i].position + labelHeight / 2;
-      const bTop = sorted[i + 1].position - labelHeight / 2;
-      if (aBottom + minGap > bTop) return true;
-    }
-    return false;
-  }
-
-  for (let i = 0; i < ticks.length - 1; i++) {
-    const aWidth = measureLabel(ticks[i].label, fontSize, fontWeight, measureText);
-    const bWidth = measureLabel(ticks[i + 1].label, fontSize, fontWeight, measureText);
-    const aRight = ticks[i].position + aWidth / 2;
-    const bLeft = ticks[i + 1].position - bWidth / 2;
-    if (aRight + minGap > bLeft) return true;
-  }
-  return false;
-}
-
-/**
- * Thin a tick array by removing every other tick until labels don't overlap.
- * Always keeps first and last tick. O(log n) iterations max.
- * Returns the original array if no thinning is needed.
- */
-export function thinTicksUntilFit(
-  ticks: AxisTick[],
-  fontSize: number,
-  fontWeight: number,
-  measureText?: MeasureTextFn,
-  orientation: 'horizontal' | 'vertical' = 'horizontal',
-): AxisTick[] {
-  if (!ticksOverlap(ticks, fontSize, fontWeight, measureText, orientation)) return ticks;
-
-  let current = ticks;
-  while (current.length > MIN_TICK_COUNT) {
-    // Keep first, last, and every other tick in between
-    const thinned = [current[0]];
-    for (let i = 2; i < current.length - 1; i += 2) {
-      thinned.push(current[i]);
-    }
-    if (current.length > 1) thinned.push(current[current.length - 1]);
-    current = thinned;
-
-    if (!ticksOverlap(current, fontSize, fontWeight, measureText, orientation)) break;
-  }
-  return current;
-}

package/src/layout/axes/ticks.ts

@@ -1,409 +0,0 @@
-/**
- * Tick generation: produces raw AxisTick[] from a resolved scale.
- *
- * Pure with respect to layout dimensions — positions come from the scale,
- * not from the chart area. Density thinning lives in ./thinning.ts.
- */
-
-import type { AxisLabelDensity, AxisTick, DataRow } from '@opendata-ai/openchart-core';
-import {
-  buildTemporalFormatter,
-  formatDate,
-  resolveNumberFormatter,
-} from '@opendata-ai/openchart-core';
-import type { ScaleBand } from 'd3-scale';
-import { resolveFieldFormatter } from '../../format/field-format';
-import type { D3CategoricalScale, D3ContinuousScale, ResolvedScale } from '../scales';
-
-/**
- * Target pixels-per-tick for continuous axes. The target count is computed as
- * `axisLength / PX_PER_TICK[density]` and then clamped into the count range.
- *
- * Rationale:
- * - Observable Plot uses 50px/tick on y, 80px/tick on x as its baseline.
- * - ONS editorial guidance recommends 6-10 y-gridlines at desktop, 3-6 mobile.
- * - The Economist / FT / NYT typically show 4-6 labeled y-ticks on finished charts.
- *
- * Y gets tighter spacing than X because vertical label extent is the font height
- * (~14px) versus horizontal label extent which can be 60-100px for dates/abbreviated
- * numbers. X uses wider spacing so labels don't need aggressive rotation or thinning.
- *
- * "full" is the publication-ready default; "reduced" and "minimal" step down as the
- * responsive breakpoint system shifts to smaller containers.
- *
- * Y full is set to 40px/tick (tighter than Observable Plot's 50) because chart areas
- * are measured after chrome subtraction. A 400px container with title+subtitle leaves
- * ~270px of chart area; 55px/tick would only produce 4 ticks. 40px/tick reaches 5-6
- * on typical chart areas (150-300px) and the overlap check acts as a safety net.
- *
- * @internal — these are tuning constants, not part of the configuration API.
- * Consumers should configure tick density through `axis.tickCount` on the spec.
- */
-const Y_PX_PER_TICK: Record<AxisLabelDensity, number> = {
-  full: 40,
-  reduced: 70,
-  minimal: 120,
-};
-
-const X_PX_PER_TICK: Record<AxisLabelDensity, number> = {
-  full: 110,
-  reduced: 160,
-  minimal: 220,
-};
-
-/**
- * Count clamps per density. The lower bound keeps a chart from collapsing to
- * a single label on very short axes; the upper bound stops tall/wide charts
- * from growing a ladder of ticks past the point of editorial usefulness.
- *
- * The upper bound is deliberately <=6 for y on standard tiers: D3's
- * `scale.ticks(n)` only produces "nice" step sizes (1, 2, 5 × 10^k), and for
- * many domains the jump from step=10 to step=5 happens between count 6 and 7.
- * Requesting 7 can give back 10, which reads as visually dense. Capping at 6
- * keeps the editorial ~5 gridline average regardless of domain shape.
- *
- * @internal — see PX_PER_TICK comment.
- */
-const Y_TICK_COUNT_RANGE: Record<AxisLabelDensity, [number, number]> = {
-  full: [4, 6],
-  reduced: [3, 5],
-  minimal: [2, 3],
-};
-
-const X_TICK_COUNT_RANGE: Record<AxisLabelDensity, [number, number]> = {
-  full: [3, 6],
-  reduced: [3, 5],
-  minimal: [2, 3],
-};
-
-/**
- * Fallback tick counts for callers that don't have an axis length handy
- * (categorical band-scale thinning uses this as a cap, and `continuousTicks`
- * uses it when no `targetCount` is provided).
- *
- * @internal
- */
-const TICK_COUNTS: Record<AxisLabelDensity, number> = {
-  full: 7,
-  reduced: 5,
-  minimal: 3,
-};
-
-/**
- * Compute a target tick count for a continuous axis from its pixel length and
- * density tier. Uses the Plot-style pixels-per-tick heuristic, then clamps
- * into the density's count range.
- */
-export function targetTickCount(
-  axisLength: number,
-  density: AxisLabelDensity,
-  orientation: 'x' | 'y',
-): number {
-  const pxPerTick = orientation === 'y' ? Y_PX_PER_TICK[density] : X_PX_PER_TICK[density];
-  const [min, max] =
-    orientation === 'y' ? Y_TICK_COUNT_RANGE[density] : X_TICK_COUNT_RANGE[density];
-  const raw = Math.round(axisLength / pxPerTick);
-  return Math.max(min, Math.min(max, raw));
-}
-
-/** Set of continuous numeric scale types that should format as numbers. */
-const NUMERIC_SCALE_TYPES = new Set([
-  'linear',
-  'log',
-  'pow',
-  'sqrt',
-  'symlog',
-  'quantile',
-  'quantize',
-  'threshold',
-]);
-
-/** Set of temporal scale types. */
-const TEMPORAL_SCALE_TYPES = new Set(['time', 'utc']);
-
-interface TickContext {
-  step?: number;
-  maxAbsTick?: number;
-}
-
-/** Format a tick value based on the scale type. */
-function formatTickLabel(
-  value: unknown,
-  resolvedScale: ResolvedScale,
-  compact = false,
-  tickContext?: TickContext,
-): string {
-  const axisConfig = resolvedScale.channel.axis || undefined;
-  const formatStr = axisConfig?.format;
-  const suffix = axisConfig?.labelSuffix ?? '';
-
-  if (TEMPORAL_SCALE_TYPES.has(resolvedScale.type)) {
-    // Explicit user axis.format always wins, compact or not.
-    const temporalFmt = buildTemporalFormatter(formatStr);
-    if (temporalFmt) return temporalFmt(value as Date) + suffix;
-    const useUtc = resolvedScale.type === 'utc';
-    return formatDate(value as Date, undefined, undefined, useUtc, compact) + suffix;
-  }
-
-  if (NUMERIC_SCALE_TYPES.has(resolvedScale.type)) {
-    const num = value as number;
-    if (formatStr) {
-      const ctx = {
-        ...resolvedScale.formatContext,
-        step: tickContext?.step,
-        stepReference: tickContext?.maxAbsTick,
-      };
-      const fmt = resolveNumberFormatter(formatStr, ctx);
-      if (fmt) return fmt(num) + suffix;
-    }
-    const fmt = resolveFieldFormatter({
-      channelFormat: resolvedScale.channel.format,
-      context: {
-        ...resolvedScale.formatContext,
-        step: tickContext?.step,
-        stepReference: tickContext?.maxAbsTick,
-      },
-    });
-    return fmt(num) + suffix;
-  }
-
-  return String(value) + suffix;
-}
-
-function computeTickContext(ticks: unknown[]): TickContext | undefined {
-  if (ticks.length < 2) return undefined;
-  const nums = ticks.filter((v) => typeof v === 'number' && Number.isFinite(v)) as number[];
-  if (nums.length < 2) return undefined;
-
-  const firstGap = Math.abs(nums[1] - nums[0]);
-  if (firstGap === 0) return undefined;
-
-  let uniform = true;
-  for (let i = 2; i < nums.length; i++) {
-    const gap = Math.abs(nums[i] - nums[i - 1]);
-    const relDiff = Math.abs(gap - firstGap) / Math.max(firstGap, 1e-15);
-    if (relDiff > 1e-9) {
-      uniform = false;
-      break;
-    }
-  }
-
-  if (!uniform) return undefined;
-
-  return {
-    step: firstGap,
-    maxAbsTick: Math.max(Math.abs(nums[0]), Math.abs(nums[nums.length - 1])),
-  };
-}
-
-/**
- * Generate ticks for a continuous scale (linear, time, log, pow, sqrt, symlog).
- *
- * `targetCount` lets callers that know the axis pixel length pass a
- * density-appropriate count (see `targetTickCount`). When omitted, falls back
- * to the coarse `TICK_COUNTS` tier, which is only used by tests and callers
- * that don't have an axis length.
- */
-export function continuousTicks(
-  resolvedScale: ResolvedScale,
-  density: AxisLabelDensity,
-  targetCount?: number,
-): AxisTick[] {
-  const scale = resolvedScale.scale as D3ContinuousScale;
-
-  // Discretizing scales (quantile, quantize, threshold) don't have .ticks().
-  // Use their domain thresholds as ticks instead.
-  if (!('ticks' in scale) || typeof scale.ticks !== 'function') {
-    const domain = scale.domain() as unknown[];
-    return domain.map((value: unknown) => ({
-      value,
-      position: (scale as D3ContinuousScale)(value as number & Date) as number,
-      label: formatTickLabel(value, resolvedScale),
-    }));
-  }
-
-  const axCfg = resolvedScale.channel.axis || undefined;
-  const count = axCfg?.tickCount ?? targetCount ?? TICK_COUNTS[density];
-  return buildContinuousTicks(resolvedScale, count);
-}
-
-/**
- * Build positioned, labeled ticks for a continuous scale at an exact count.
- * Exposed so callers that need to re-request ticks at a lower count (for
- * overlap-driven density adaptation) can regenerate without manual pruning.
- * D3's `scale.ticks(n)` always returns evenly-spaced round values, so
- * requesting a smaller `n` never produces squished neighbors — unlike
- * "keep first+last, drop middle" pruning which can stack the last tick
- * next to an endpoint and cascade to 2 ticks.
- *
- * `compact` switches temporal labels to the compact format table (bare '%b'
- * months etc.); numeric and string labels ignore it.
- */
-export function buildContinuousTicks(
-  resolvedScale: ResolvedScale,
-  count: number,
-  compact = false,
-): AxisTick[] {
-  const scale = resolvedScale.scale as D3ContinuousScale;
-  if (!('ticks' in scale) || typeof scale.ticks !== 'function') {
-    return continuousTicks(resolvedScale, 'full');
-  }
-  const raw: unknown[] = scale.ticks(count);
-
-  // D3 log scales ignore the count hint and return ticks at every sub-power
-  // position (e.g. 5, 6, 7, 8, 9, 10, 20, 30... for a domain of [5, 25000]).
-  // Filter down to powers of the base only when the raw set overshoots.
-  let ticks = raw;
-  if (resolvedScale.type === 'log' && raw.length > count) {
-    const base = resolvedScale.channel.scale?.base ?? 10;
-    const logBase = Math.log(base);
-    const powered = raw.filter((v) => {
-      const n = v as number;
-      if (n <= 0) return false;
-      const exp = Math.log(n) / logBase;
-      return Math.abs(exp - Math.round(exp)) < 1e-9;
-    });
-    // Only use the filtered set if it has at least 2 ticks; otherwise fall back
-    // to raw ticks. This handles domains like [5, 9] (no powers of 10 at all) or
-    // [5, 50] (only one power: 10) where filtering would leave too few meaningful ticks.
-    if (powered.length >= 2) {
-      ticks = powered;
-    }
-  }
-
-  const tickCtx = computeTickContext(ticks);
-
-  return ticks.map((value: unknown) => ({
-    value,
-    position: scale(value as number & Date) as number,
-    label: formatTickLabel(value, resolvedScale, compact, tickCtx),
-  }));
-}
-
-/** True if this scale supports regenerating ticks at an arbitrary count. */
-export function scaleSupportsTickCount(resolvedScale: ResolvedScale): boolean {
-  const scale = resolvedScale.scale as D3ContinuousScale;
-  return 'ticks' in scale && typeof scale.ticks === 'function';
-}
-
-/**
- * Generate ticks for a band/point/ordinal scale.
- *
- * For horizontal x-axis band scales, thinning is geometry-aware: if
- * `bandwidth` and `fontSize`/`fontWeight` are provided, labels are only
- * thinned when the estimated label footprint (accounting for `labelAngle`)
- * actually exceeds the bandwidth. When labels are rotated, their horizontal
- * footprint shrinks by |cos(angle)|, so far fewer need to be removed.
- * Falls back to a density-count cap when geometry info is unavailable.
- */
-export function categoricalTicks(
-  resolvedScale: ResolvedScale,
-  density: AxisLabelDensity,
-  orientation: 'horizontal' | 'vertical' = 'horizontal',
-  subtitleContext?: { data: DataRow[]; fieldName: string; labelField: string },
-): AxisTick[] {
-  const scale = resolvedScale.scale as D3CategoricalScale;
-  const domain: string[] = scale.domain();
-  const catAxisCfg = resolvedScale.channel.axis || undefined;
-  const explicitTickCount = catAxisCfg?.tickCount;
-
-  let selectedValues = domain;
-
-  if (resolvedScale.type === 'band' && orientation === 'horizontal') {
-    // Horizontal band scales delegate thinning to the caller (computeAxes)
-    // which knows the effective label angle after auto-rotation. Only apply
-    // an explicit tickCount cap here; the angle ladder + stride safety net
-    // (see ./rotation) handle collisions downstream.
-    if (explicitTickCount && domain.length > explicitTickCount) {
-      const step = Math.ceil(domain.length / explicitTickCount);
-      selectedValues = domain.filter((_: string, i: number) => i % step === 0);
-    }
-  } else if (resolvedScale.type !== 'band') {
-    // Point/ordinal scales: thin by density count
-    const maxTicks = explicitTickCount ?? TICK_COUNTS[density];
-    if (domain.length > maxTicks) {
-      const step = Math.ceil(domain.length / maxTicks);
-      selectedValues = domain.filter((_: string, i: number) => i % step === 0);
-    }
-  }
-  // vertical band scale (horizontal bar y-axis): always show all labels
-
-  let subtitleMap: Map<string, string> | undefined;
-  if (subtitleContext) {
-    const { data, fieldName, labelField } = subtitleContext;
-    if (data.length > 0) {
-      subtitleMap = new Map();
-      for (const row of data) {
-        const key = String(row[fieldName] ?? '');
-        if (!subtitleMap.has(key)) {
-          const val = row[labelField];
-          if (val != null) {
-            subtitleMap.set(key, String(val));
-          }
-        }
-      }
-    }
-  }
-
-  const ticks = selectedValues.map((value: string) => {
-    // Band scales: use the center of the band
-    const bandScale = resolvedScale.type === 'band' ? (scale as ScaleBand<string>) : null;
-    const pos = bandScale
-      ? (bandScale(value) ?? 0) + bandScale.bandwidth() / 2
-      : ((scale(value) as number | undefined) ?? 0);
-
-    const tick: AxisTick = {
-      value,
-      position: pos,
-      label: value,
-    };
-
-    if (subtitleMap) {
-      const subtitle = subtitleMap.get(value);
-      if (subtitle !== undefined) {
-        tick.subtitle = subtitle;
-      }
-    }
-
-    return tick;
-  });
-
-  return ticks;
-}
-
-/**
- * Resolve explicit tick values from axis config into positioned ticks.
- *
- * Deliberately never compact: this renders the layout planner's precomputed
- * ticks, and planner/renderer gutter agreement holds only because both sides
- * format identically. Making this compact without making the planner compact
- * recreates the reserved-space divergence bug class behind the 7.9.x saga.
- */
-export function resolveExplicitTicks(values: unknown[], resolvedScale: ResolvedScale): AxisTick[] {
-  const scale = resolvedScale.scale;
-  const tickCtx = computeTickContext(values);
-  return values.map((value) => {
-    let position: number;
-    if (TEMPORAL_SCALE_TYPES.has(resolvedScale.type)) {
-      const d = value instanceof Date ? value : new Date(String(value));
-      position = (scale as D3ContinuousScale)(d as number & Date) as number;
-    } else if (
-      resolvedScale.type === 'band' ||
-      resolvedScale.type === 'point' ||
-      resolvedScale.type === 'ordinal'
-    ) {
-      const s = String(value);
-      const bandScale = resolvedScale.type === 'band' ? (scale as ScaleBand<string>) : null;
-      position = bandScale
-        ? (bandScale(s) ?? 0) + bandScale.bandwidth() / 2
-        : ((scale(s as string & number) as number | undefined) ?? 0);
-    } else {
-      position = (scale as D3ContinuousScale)(value as number & Date) as number;
-    }
-    return {
-      value,
-      position,
-      label: formatTickLabel(value, resolvedScale, false, tickCtx),
-    };
-  });
-}