@opendata-ai/openchart-engine 7.2.4 → 7.4.0

package/src/compile.ts

@@ -3,8 +3,9 @@
  *
  * Pipeline for charts:
  *   validate spec -> normalize -> resolve theme -> dark mode adapt ->
- *   compute legend -> compute dimensions (with legend space) ->
- *   compute scales -> compute axes -> compute gridlines ->
+ *   filter data -> resolveLayoutPlan (measure real labels) ->
+ *   compute dimensions (with plan) -> placeLegend ->
+ *   compute scales -> compute axes (with pinned ticks) -> compute gridlines ->
  *   get chart renderer -> compute marks -> compute a11y -> return ChartLayout
  *
  * Table compiler handles full data pipeline (sort, search, pagination, visual enhancements).
@@ -23,7 +24,6 @@ import type {
   EncodingChannel,
   LayerSpec,
   Mark,
-  Rect,
   ResolvedAnnotation,
   ResolvedTheme,
   TableLayout,
@@ -34,7 +34,6 @@ import type {
 import {
   adaptTheme,
   computeLabelBounds,
-  estimateTextWidth,
   generateAltText,
   generateDataTable,
   getBreakpoint,
@@ -42,8 +41,9 @@ import {
   getLayoutStrategy,
   resolveTheme,
 } from '@opendata-ai/openchart-core';
-import { format as d3Format } from 'd3-format';
 import { computeAnnotations } from './annotations/compute';
+import { type AnnotationMeasureTextFn, heuristicMeasure } from './annotations/geometry';
+import type { PlacementObstacle } from './annotations/placement';
 import { computeEndpointLabels } from './endpoint-labels/compute';
 // Side-effect import: registers all built-in chart renderers with the
 // registry on module load. Tests that clear the registry can import
@@ -74,9 +74,9 @@ import type { GraphCompilation } from './graphs/types';
 import { computeAxes } from './layout/axes';
 import { computeDimensions } from './layout/dimensions';
 import { computeGridlines } from './layout/gridlines';
+import { createMeasureFn, resolveLayoutPlan } from './layout/plan';
 import { computeScales } from './layout/scales';
-import { computeLegend } from './legend/compute';
-import { legendGap } from './legend/wrap';
+import { placeLegend } from './legend/compute';
 import { compileSankey as compileSankeyImpl } from './sankey/compile-sankey';
 import { compileTableLayout } from './tables/compile-table';
 import { compileTileMap as compileTileMapImpl } from './tilemap/compile-tilemap';
@@ -533,70 +533,11 @@ export function compileChart(spec: unknown, options: CompileOptions): ChartLayou
     chartSpec = applySparklineDefaults(chartSpec, theme);
   }
 
-  // INVARIANT 1 — double legend pass: preliminaryArea → computeDimensions → legendArea → final
-  // legend. Breaks a dims/legend dependency cycle. Do not collapse into one call.
-  // Compute legend first (needs to reserve space)
-  const preliminaryArea: Rect = {
-    x: 0,
-    y: 0,
-    width: options.width,
-    height: options.height,
-  };
-  const legendLayout = computeLegend(chartSpec, strategy, theme, preliminaryArea, watermark);
-
-  // Compute dimensions (accounts for chrome + legend + responsive strategy)
-  const dims = computeDimensions(chartSpec, options, legendLayout, theme, strategy, watermark);
-  const chartArea = dims.chartArea;
-
-  // Recompute legend bounds relative to actual chart area.
-  // chartArea was shrunk to exclude legend space, so expand it back to include
-  // the reserved margin. This way computeLegend positions the legend outside
-  // the data area (in the margin) instead of overlapping data marks.
-  //
-  // Top/bottom legends align their left edge to the plot area (chartArea.x),
-  // so the legend sits above/below the y-axis guide rather than flush against
-  // the container edge.
-  //
-  // Width runs from the new left origin (chartArea.x) to the container's right
-  // padding, so the rendered legend never paints past the right edge / over the
-  // endpoint-label column. This is narrower than the first pass (which used the
-  // full container at preliminaryArea.width = options.width), so on a chart with
-  // BOTH a wide y-axis gutter AND a legend that nearly fills its row, the second
-  // pass can wrap to one more row than the first pass reserved in margins.top —
-  // the extra row protrudes slightly into the chrome gap. That graceful failure
-  // (a few px of vertical crowding, still on-canvas) is preferable to the
-  // alternative (chips clipped off the right edge of the SVG). The maxRows cap
-  // (default 2 for top legends) bounds the worst case to a single extra row.
-  const legendArea: Rect = { ...chartArea };
-  if ('entries' in legendLayout && legendLayout.entries.length > 0) {
-    const legendInnerWidth = options.width - theme.spacing.padding - chartArea.x;
-    const gap = legendGap(options.width);
-    switch (legendLayout.position) {
-      case 'top':
-        legendArea.x = chartArea.x;
-        legendArea.width = legendInnerWidth;
-        legendArea.y -= legendLayout.bounds.height + gap;
-        legendArea.height += legendLayout.bounds.height + gap;
-        break;
-      case 'bottom':
-        legendArea.x = chartArea.x;
-        legendArea.width = legendInnerWidth;
-        // Bottom legend sits below the x-axis tick row, not over it. Expand
-        // legendArea by xAxisHeight + legendHeight + gap so the bottom-anchored
-        // legend lands beneath the axis. Mirrors dimensions.ts which reserved
-        // the same xAxisHeight in margins.bottom.
-        legendArea.height += legendLayout.bounds.height + gap + dims.xAxisHeight;
-        break;
-      case 'right':
-      case 'bottom-right':
-        legendArea.width += legendLayout.bounds.width + 8;
-        break;
-    }
-  }
-  const finalLegend = computeLegend(chartSpec, strategy, theme, legendArea, watermark);
-
-  // Apply data filtering after legend (so legend retains all series), but before
-  // scale computation (so hidden/clipped data doesn't affect domains or marks).
+  // ---------------------------------------------------------------------------
+  // Data filtering: move BEFORE layout plan so the plan measures real labels
+  // from the filtered data set. Legend retains all series via chartSpec
+  // (unfiltered); scales and marks use renderSpec (filtered).
+  // ---------------------------------------------------------------------------
   let renderData = chartSpec.data;
 
   // Filter hidden series: removed from rendering but kept in legend (dimmed in the adapter)
@@ -619,7 +560,7 @@ export function compileChart(spec: unknown, options: CompileOptions): ChartLayou
   // Lock the color scale domain to the unfiltered series list so palette
   // assignments stay stable across legend toggles. Without this, hiding a
   // series shrinks the ordinal scale's domain and shifts every remaining
-  // series down one palette index — the visible lines would mismatch the
+  // series down one palette index -- the visible lines would mismatch the
   // legend swatches that still represent the original assignment.
   // Skipped when the user already supplied an explicit domain.
   const colorEnc = chartSpec.encoding.color;
@@ -644,73 +585,53 @@ export function compileChart(spec: unknown, options: CompileOptions): ChartLayou
     };
   }
 
-  // Inline y-axis labels render at chartArea.x with text-anchor=start. Without
-  // an inset the leftmost data point on a line/area would clip through the
-  // label glyphs (since the line begins at chartArea.x too). Inset the x-scale
-  // range start by the widest tick label width so the data starts to the right
-  // of the labels. Axes/gridlines still span the full chart area, so inline
-  // labels stay flush left where the design intends.
-  const yEnc = renderSpec.encoding?.y;
-  const yAxisCfgInline =
-    typeof yEnc?.axis === 'object' && yEnc.axis !== null
-      ? (yEnc.axis as Record<string, unknown>)
-      : undefined;
-  const yIsContinuous = yEnc?.type === 'quantitative' || yEnc?.type === 'temporal';
-  const isLineOrArea = renderSpec.markType === 'line' || renderSpec.markType === 'area';
-  const yInlineExplicit = yAxisCfgInline?.tickPosition as 'inline' | 'gutter' | undefined;
-  // Sparkline mode hides the y-axis by default, so the inline-label inset
-  // would shrink the data range without any labels actually being drawn —
-  // the line ends up starting ~30px from the left edge for no visible
-  // reason. Skip the inset unless the user explicitly opted into the
-  // y-axis (in which case the labels do render and the inset is needed).
-  const sparklineSuppressesYAxis =
-    chartSpec.display === 'sparkline' && !chartSpec.userExplicit.yAxis;
-  const yIsInline =
-    !sparklineSuppressesYAxis &&
-    (yInlineExplicit === 'inline' ||
-      (yInlineExplicit === undefined &&
-        isLineOrArea &&
-        yIsContinuous &&
-        yAxisCfgInline?.orient !== 'right'));
+  // ---------------------------------------------------------------------------
+  // Layout plan: measure real labels, freeze gutter + chrome + legend content
+  // ---------------------------------------------------------------------------
+  const measure = createMeasureFn(options.measureText);
+  const plan = resolveLayoutPlan(
+    chartSpec,
+    renderSpec,
+    options,
+    theme,
+    strategy,
+    watermark,
+    measure,
+  );
+
+  // Compute dimensions (accounts for chrome + legend + responsive strategy).
+  // The plan provides measured leftGutter, xAxisExtent, and chrome so
+  // dimensions.ts skips its guess blocks.
+  const legendStub = placeLegend(
+    plan.legendContent,
+    { x: 0, y: 0, width: options.width, height: options.height },
+    options.width,
+    theme,
+    plan.xAxisExtent,
+  );
+  const dims = computeDimensions(chartSpec, options, legendStub, theme, strategy, watermark, plan);
+  const chartArea = dims.chartArea;
+
+  // Place legend in its final position relative to the computed chart area.
+  const finalLegend = placeLegend(
+    plan.legendContent,
+    chartArea,
+    options.width,
+    theme,
+    plan.xAxisExtent,
+  );
+
+  // Inline y-axis labels: inset the x-scale range start by the widest tick
+  // label width so data marks start to the right of the labels. The plan
+  // already measured the real tick labels.
   let scaleArea = chartArea;
-  if (yIsInline && yEnc && yIsContinuous && yEnc.axis !== false) {
-    const yField = yEnc.field;
-    const yFmt = yAxisCfgInline?.format as string | undefined;
-    let maxAbsVal = 0;
-    for (const row of renderSpec.data) {
-      const v = Number(row[yField]);
-      if (Number.isFinite(v) && Math.abs(v) > maxAbsVal) maxAbsVal = Math.abs(v);
-    }
-    let sample: string;
-    if (yFmt) {
-      try {
-        sample = d3Format(yFmt)(maxAbsVal);
-      } catch {
-        sample = String(maxAbsVal);
-      }
-    } else if (maxAbsVal >= 1_000_000_000) sample = '1.5B';
-    else if (maxAbsVal >= 1_000_000) sample = '1.5M';
-    else if (maxAbsVal >= 1_000) sample = '1.5K';
-    else if (maxAbsVal >= 100) sample = '100';
-    else if (maxAbsVal >= 10) sample = '10';
-    else sample = '0.0';
-    const negPrefix = renderSpec.data.some((r) => Number(r[yField]) < 0) ? '-' : '';
-    const labelEst = negPrefix + sample;
-    const labelWidth = estimateTextWidth(
-      labelEst,
-      theme.fonts.sizes.axisTick,
-      theme.fonts.weights.normal,
-    );
-    const INLINE_LABEL_BREATHING_ROOM = 8;
-    const inset = Math.ceil(labelWidth + INLINE_LABEL_BREATHING_ROOM);
-    if (inset > 0 && inset < chartArea.width) {
-      scaleArea = {
-        x: chartArea.x + inset,
-        y: chartArea.y,
-        width: chartArea.width - inset,
-        height: chartArea.height,
-      };
-    }
+  if (plan.inlineYLabelInset > 0 && plan.inlineYLabelInset < chartArea.width) {
+    scaleArea = {
+      x: chartArea.x + plan.inlineYLabelInset,
+      y: chartArea.y,
+      width: chartArea.width - plan.inlineYLabelInset,
+      height: chartArea.height,
+    };
   }
 
   // Compute scales
@@ -719,7 +640,7 @@ export function compileChart(spec: unknown, options: CompileOptions): ChartLayou
   // Update color scale to use theme palette (only when user hasn't provided an explicit range)
   applyColorScaleRange(scales, renderSpec.encoding, theme);
 
-  // INVARIANT 3 — post-hoc defaultColor: must run AFTER computeScales since resolution needs
+  // INVARIANT 3 -- post-hoc defaultColor: must run AFTER computeScales since resolution needs
   // theme context. Do not move into computeScales (would require threading theme through).
   // fill wins for bar/area/arc marks; stroke wins for line marks (the stroke IS the color).
   scales.defaultColor =
@@ -741,8 +662,14 @@ export function compileChart(spec: unknown, options: CompileOptions): ChartLayou
         skipX,
         skipY,
         markType: chartSpec.markType,
+        totalWidth: options.width,
+        precomputedYTicks: plan.yTickValues.length > 0 ? plan.yTickValues : undefined,
       });
 
+  // Intentional post-hoc mutation: axes must resolve before we know the x-axis extent.
+  const xAxisExtent = axes.x?.extent ?? 0;
+  dims.chrome.bottomAnchorY = chartArea.y + chartArea.height + xAxisExtent;
+
   // INVARIANT 2 — computeGridlines mutates `axes` in place. Downstream consumers read
   // axes.y.gridlines off the same object. Do not introduce a copy-on-write.
   if (!isRadial) {
@@ -756,7 +683,9 @@ export function compileChart(spec: unknown, options: CompileOptions): ChartLayou
     renderSpec.markDef,
   );
   const renderer = getChartRenderer(rendererKey);
-  const marks: Mark[] = renderer ? renderer(renderSpec, scales, chartArea, strategy, theme) : [];
+  const marks: Mark[] = renderer
+    ? renderer(renderSpec, scales, chartArea, strategy, theme, options.width)
+    : [];
 
   // Compute the right-side endpoint labels column for multi-series line/area
   // charts. Reads `mark.dataPoints` so it must run AFTER marks are computed.
@@ -764,31 +693,41 @@ export function compileChart(spec: unknown, options: CompileOptions): ChartLayou
   const endpointLabels = computeEndpointLabels(chartSpec, marks, theme, chartArea, strategy);
 
   // Compute annotations from spec, passing legend + mark + brand bounds as obstacles
-  const obstacles: Rect[] = [];
+  const obstacles: PlacementObstacle[] = [];
   if (finalLegend.bounds.width > 0) {
-    obstacles.push(finalLegend.bounds);
+    obstacles.push({ ...finalLegend.bounds, kind: 'legend' });
   }
   obstacles.push(...computeMarkObstacles(marks, scales));
 
   // Add visible data label bounds as obstacles so annotations avoid overlapping them
   for (const mark of marks) {
     if ('label' in mark && mark.label?.visible) {
-      obstacles.push(computeLabelBounds(mark.label));
+      obstacles.push({ ...computeLabelBounds(mark.label), kind: 'data-label' });
     }
   }
 
   // Add brand watermark as an obstacle so annotations avoid overlapping it.
   const watermarkRect = computeWatermarkObstacle(dims, watermark, axes, theme);
-  if (watermarkRect) obstacles.push(watermarkRect);
-  const annotations: ResolvedAnnotation[] = computeAnnotations(
-    chartSpec,
+  if (watermarkRect) obstacles.push({ ...watermarkRect, kind: 'watermark' });
+
+  // Add endpoint label bounds as obstacles
+  if (endpointLabels.entries.length > 0 && endpointLabels.bounds.width > 0) {
+    obstacles.push({ ...endpointLabels.bounds, kind: 'endpoint-label' });
+  }
+
+  const annotationMeasure: AnnotationMeasureTextFn = options.measureText
+    ? (text, font) => options.measureText!(text, font.fontSize, font.fontWeight).width
+    : heuristicMeasure;
+
+  const annotations: ResolvedAnnotation[] = computeAnnotations(chartSpec, {
     scales,
     chartArea,
     strategy,
-    theme.isDark,
+    isDark: theme.isDark,
     obstacles,
-    { width: dims.total.width, height: dims.total.height },
-  );
+    svg: { width: dims.total.width, height: dims.total.height },
+    measure: annotationMeasure,
+  });
 
   // Compute tooltip descriptors from marks and encoding
   const tooltipDescriptors = computeTooltipDescriptors(chartSpec, marks);

package/src/index.ts

@@ -53,6 +53,15 @@ export type { NormalizedBarListSpec } from './barlist/types';
 
 export type { NormalizedTileMapSpec } from './tilemap/types';
 
+// ---------------------------------------------------------------------------
+// Annotations
+// ---------------------------------------------------------------------------
+
+export type { AnnotationContext } from './annotations/compute';
+export type { AnnotationMeasureTextFn } from './annotations/geometry';
+export { heuristicMeasure } from './annotations/geometry';
+export type { ObstacleKind, PlacementObstacle } from './annotations/placement';
+
 // ---------------------------------------------------------------------------
 // Compiler pipeline (spec validation, normalization, generic compile)
 // ---------------------------------------------------------------------------

package/src/layout/axes/rotation.ts

@@ -0,0 +1,36 @@
+/**
+ * Auto-rotation decision for band-scale x-axis tick labels.
+ *
+ * Vertical band x-axes rotate their tick labels to -45° when horizontal
+ * labels are wider than the available band. The layout planner and
+ * computeAxes must agree on this decision: the planner reserves the bottom
+ * margin for the rotated label footprint, and computeAxes emits the same
+ * angle. Sharing this rule keeps the reserved space matched to the rendered
+ * labels (a mismatch spilled rotated ticks into the source line).
+ */
+
+/** Band fraction above which horizontal labels are considered too wide to fit. */
+const BAND_FIT_FRACTION = 0.85;
+
+/** Angle used when band labels don't fit horizontally. */
+const AUTO_ROTATE_ANGLE = -45;
+
+/**
+ * Decide the effective x tick angle for a band scale.
+ *
+ * @param explicitAngle - User-specified labelAngle (wins if defined).
+ * @param maxLabelWidth - Widest tick label width in pixels.
+ * @param bandwidth - Band width in pixels.
+ * @param labelCount - Number of category labels (rotation needs >= 2).
+ * @returns The explicit angle, `-45` if auto-rotation triggers, or `undefined`.
+ */
+export function resolveBandTickAngle(
+  explicitAngle: number | undefined,
+  maxLabelWidth: number,
+  bandwidth: number,
+  labelCount: number,
+): number | undefined {
+  if (explicitAngle !== undefined) return explicitAngle;
+  if (labelCount < 2) return undefined;
+  return maxLabelWidth > bandwidth * BAND_FIT_FRACTION ? AUTO_ROTATE_ANGLE : undefined;
+}

package/src/layout/axes.ts

@@ -19,7 +19,15 @@ import type {
   ResolvedTheme,
   TextStyle,
 } from '@opendata-ai/openchart-core';
+import {
+  axisTitleOffset,
+  computeXAxisExtentFromLabels,
+  estimateTextWidth,
+  getAxisTitleOffset,
+  X_AXIS_TITLE_BAND_ROTATED,
+} from '@opendata-ai/openchart-core';
 import type { ScaleBand } from 'd3-scale';
+import { resolveBandTickAngle } from './axes/rotation';
 import { measureLabel, thinTicksUntilFit, ticksOverlap } from './axes/thinning';
 import {
   buildContinuousTicks,
@@ -123,6 +131,40 @@ const CONTINUOUS_TICK_FLOOR = 4;
  */
 const OVERSHOOT_TOLERANCE = 1.5;
 
+/**
+ * Quantitative axes must always render at least this many tick labels. A lone
+ * tick reads as a broken axis (a real iPhone blog chart degenerated to a
+ * single "80" when D3's `scale.ticks(2)` collapsed a tight domain like
+ * [73, 88] to one nice value). This floor holds at every width.
+ */
+const MIN_QUANTITATIVE_TICKS = 2;
+
+/**
+ * Ensure a continuous scale yields at least MIN_QUANTITATIVE_TICKS ticks.
+ *
+ * D3's `scale.ticks(n)` picks nice step sizes, so a tight domain can collapse
+ * to a single value at low counts (`[73, 88].ticks(2)` → `[80]`). When that
+ * happens, request progressively higher counts until at least two ticks
+ * appear. Prefers the smallest count that clears the floor, which keeps the
+ * ticks spread toward the domain endpoints rather than clustered.
+ */
+function ensureMinContinuousTicks(
+  scale: ResolvedScales['x' | 'y'],
+  ticks: AxisTick[],
+  requestedCount: number,
+): AxisTick[] {
+  if (ticks.length >= MIN_QUANTITATIVE_TICKS) return ticks;
+  if (!scale || !scaleSupportsTickCount(scale)) return ticks;
+
+  let best = ticks;
+  for (let n = Math.max(requestedCount, MIN_QUANTITATIVE_TICKS) + 1; n <= 10; n++) {
+    const candidate = buildContinuousTicks(scale, n);
+    if (candidate.length >= MIN_QUANTITATIVE_TICKS) return candidate;
+    if (candidate.length > best.length) best = candidate;
+  }
+  return best;
+}
+
 /**
  * Fit continuous ticks by re-requesting progressively fewer ticks from the
  * scale. D3's `scale.ticks(n)` always returns evenly-spaced round values, so
@@ -152,10 +194,15 @@ function fitContinuousTicks(
 ): AxisTick[] {
   if (!scale || !scaleSupportsTickCount(scale)) return initialTicks;
 
+  // Floor the initial set: a tight domain can make D3 return a single nice
+  // value, which would otherwise pass straight through (no overlap, no
+  // overshoot) and render as a lone tick.
+  const flooredTicks = ensureMinContinuousTicks(scale, initialTicks, initialCount);
+
   const tolerance = initialCount * OVERSHOOT_TOLERANCE;
-  const overshoots = initialTicks.length > tolerance;
-  const overlaps = ticksOverlap(initialTicks, fontSize, fontWeight, measureText, orientation);
-  if (!overshoots && !overlaps) return initialTicks;
+  const overshoots = flooredTicks.length > tolerance;
+  const overlaps = ticksOverlap(flooredTicks, fontSize, fontWeight, measureText, orientation);
+  if (!overshoots && !overlaps) return flooredTicks;
 
   // Enforce the floor only when the axis is long enough to fit that many
   // labels without overlap. Very short axes can fall below.
@@ -186,7 +233,8 @@ function fitContinuousTicks(
   // No candidate fit cleanly. Thin whatever most recently met the floor; if
   // nothing did, synthesize a floor-count set directly from the scale so we
   // never hand the overshot initialTicks to the middle-pruning thinner.
-  const fallback = bestWithinFloor ?? buildContinuousTicks(scale, floor);
+  const rawFallback = bestWithinFloor ?? buildContinuousTicks(scale, floor);
+  const fallback = ensureMinContinuousTicks(scale, rawFallback, floor);
   return thinTicksUntilFit(fallback, fontSize, fontWeight, measureText, orientation);
 }
 
@@ -273,6 +321,15 @@ export interface AxesDataContext {
    * marks default to `'gutter'`.
    */
   markType?: import('@opendata-ai/openchart-core').MarkType;
+  /** Total container width for axis title offset threshold checks. */
+  totalWidth?: number;
+  /**
+   * Pinned y-axis tick values from the layout plan. When provided, the y-axis
+   * uses these values (via resolveExplicitTicks) instead of generating fresh
+   * ticks, so the labels match exactly what the gutter was measured for.
+   * User-specified `axis.values` still takes priority.
+   */
+  precomputedYTicks?: unknown[];
 }
 
 /**
@@ -369,9 +426,7 @@ export function computeAxes(
         const w = measureLabel(t.label, fontSize, fontWeight, measureText);
         if (w > maxLabelWidth) maxLabelWidth = w;
       }
-      if (maxLabelWidth > bandwidth * 0.85) {
-        tickAngle = -45;
-      }
+      tickAngle = resolveBandTickAngle(undefined, maxLabelWidth, bandwidth, allTicks.length);
     }
 
     // Thin tick labels to prevent overlap (skip for explicit tick values).
@@ -440,6 +495,15 @@ export function computeAxes(
     let allTicks: AxisTick[];
     if (axisConfig?.values) {
       allTicks = resolveExplicitTicks(axisConfig.values, scales.y);
+    } else if (
+      dataContext?.precomputedYTicks &&
+      dataContext.precomputedYTicks.length > 0 &&
+      isContinuousY
+    ) {
+      // Pinned ticks from the layout plan -- use the same resolution path as
+      // explicit user values so the labels match exactly what the gutter was
+      // measured for.
+      allTicks = resolveExplicitTicks(dataContext.precomputedYTicks, scales.y);
     } else if (!isContinuousY) {
       const yFieldName = dataContext?.encoding.y?.field;
       const yLabelField = axisConfig?.labelField;
@@ -458,7 +522,8 @@ export function computeAxes(
     // Thin tick labels to prevent overlap (skip for band scales and explicit tick values).
     // When tickCount is set, we still thin if D3 overshot the requested count
     // (common with log scales where ticks(4) can return 26 values).
-    const shouldThinY = scales.y.type !== 'band' && !axisConfig?.values;
+    const shouldThinY =
+      scales.y.type !== 'band' && !axisConfig?.values && !dataContext?.precomputedYTicks?.length;
     let ticks: AxisTick[];
     if (!shouldThinY) {
       ticks = allTicks;
@@ -525,5 +590,62 @@ export function computeAxes(
     };
   }
 
+  const totalWidth = dataContext?.totalWidth ?? chartArea.x + chartArea.width;
+
+  if (result.x) {
+    const isRotated = !!result.x.tickAngle && Math.abs(result.x.tickAngle) > 10;
+
+    // Single source of truth for the x-axis vertical extent (rotated or flat).
+    // computeXAxisExtentFromLabels applies the correct rotated-extent math
+    // (textWidth*|sin θ| + lineHeight*|cos θ|), so the reserved bottom margin
+    // matches what the labels actually occupy.
+    result.x.extent = computeXAxisExtentFromLabels({
+      labels: result.x.ticks.map((t) => t.label),
+      tickAngle: result.x.tickAngle,
+      hasTitle: !!result.x.label,
+      tickFontSize: result.x.tickLabelStyle.fontSize,
+      tickFontWeight: result.x.tickLabelStyle.fontWeight,
+      xAxisHeight: theme.spacing.xAxisHeight,
+      measure: (t, fs, fw) => measureLabel(t, fs, fw, measureText),
+    });
+
+    if (result.x.label) {
+      // Rotated: place the title just below the tick band (extent already
+      // includes the rotated label height and the title band). Flat: fixed 35px.
+      const rotatedBand = isRotated ? result.x.extent - X_AXIS_TITLE_BAND_ROTATED + 14 : 35;
+      result.x.titlePosition = {
+        x: chartArea.x + chartArea.width / 2,
+        y: chartArea.y + chartArea.height + rotatedBand,
+      };
+    }
+  }
+
+  if (result.y?.label && result.y.labelStyle) {
+    const isRight = result.y.orient === 'right';
+    if (isRight) {
+      const titleOff = getAxisTitleOffset(totalWidth);
+      result.y.titlePosition = {
+        x: chartArea.x + chartArea.width + titleOff,
+        y: chartArea.y + chartArea.height / 2,
+        angle: 90,
+      };
+    } else {
+      const maxTickLabelWidth = result.y.ticks.reduce((max, t) => {
+        const w = estimateTextWidth(
+          t.label,
+          result.y!.tickLabelStyle.fontSize,
+          result.y!.tickLabelStyle.fontWeight ?? 400,
+        );
+        return Math.max(max, w);
+      }, 0);
+      const titleOff = axisTitleOffset(maxTickLabelWidth, result.y.labelStyle.fontSize, totalWidth);
+      result.y.titlePosition = {
+        x: chartArea.x - titleOff,
+        y: chartArea.y + chartArea.height / 2,
+        angle: -90,
+      };
+    }
+  }
+
   return result;
 }