@opendata-ai/openchart-engine 8.0.0-rc.10 → 8.0.0-rc.12

package/src/annotations/collisions.ts

@@ -1,326 +0,0 @@
-/**
- * Collision avoidance for annotations: nudging away from obstacles,
- * resolving annotation-to-annotation overlaps, and clamping to SVG bounds.
- */
-
-import type { Rect, ResolvedAnnotation, TextAnnotation } from '@opendata-ai/openchart-core';
-import { detectCollision } from '@opendata-ai/openchart-core';
-import type { NormalizedChartSpec } from '../compiler/types';
-import type { ResolvedScales } from '../layout/scales';
-import { CLAMP_MARGIN, DEFAULT_ANNOTATION_FONT_SIZE, NUDGE_PADDING } from './constants';
-import { type AnnotationMeasureTextFn, heuristicMeasure } from './geometry';
-import { annotationBlockBounds, moveAnnotationBy } from './move';
-import { isAutoPlacement } from './placement';
-import { resolvePosition } from './position';
-
-/**
- * Generate candidate displacement vectors to move `selfBounds` clear of each
- * obstacle in 4 directions (below, above, left, right), sorted by smallest
- * movement first.
- */
-export function generateNudgeCandidates(
-  selfBounds: Rect,
-  obstacles: Rect[],
-  padding: number,
-): { dx: number; dy: number; distance: number }[] {
-  const candidates: { dx: number; dy: number; distance: number }[] = [];
-
-  for (const obs of obstacles) {
-    // Below: shift self so its top edge clears the obstacle bottom
-    const belowDy = obs.y + obs.height + padding - selfBounds.y;
-    candidates.push({ dx: 0, dy: belowDy, distance: Math.abs(belowDy) });
-
-    // Above: shift self so its bottom edge clears the obstacle top
-    const aboveDy = obs.y - padding - (selfBounds.y + selfBounds.height);
-    candidates.push({ dx: 0, dy: aboveDy, distance: Math.abs(aboveDy) });
-
-    // Left: shift self so its right edge clears the obstacle left
-    const leftDx = obs.x - padding - (selfBounds.x + selfBounds.width);
-    candidates.push({ dx: leftDx, dy: 0, distance: Math.abs(leftDx) });
-
-    // Right: shift self so its left edge clears the obstacle right
-    const rightDx = obs.x + obs.width + padding - selfBounds.x;
-    candidates.push({ dx: rightDx, dy: 0, distance: Math.abs(rightDx) });
-  }
-
-  candidates.sort((a, b) => a.distance - b.distance);
-  return candidates;
-}
-
-/**
- * Did the author hand-place this block?
- *
- * A hand-placed block goes exactly where it was put, and the automatic passes keep
- * their hands off it. Without that, the obstacle pass overrides the author: on a line
- * chart the polyline is one long obstacle, so `dy: -10` moved a block by ZERO pixels
- * while `dy: -15` teleported it 56px. Same knob, no monotonicity -- unaimable.
- *
- * `isAutoPlacement` is the ONLY definition of "did the author place this". It already
- * decides which resolve path an annotation takes, and a non-zero `offset` disqualifies
- * the scored search there, so an offset ALWAYS means hand-placed -- with or without an
- * `anchor`. A second, subtly different rule here (an earlier version of this function
- * additionally demanded an `anchor`) does not create a second tier of annotation; it
- * just disagrees with the function that actually routed the thing, and the disagreement
- * shows up as an un-aimable offset on exactly the annotations the extra condition
- * excluded.
- *
- * `offset: { dx: 0 }` is not an instruction, just the default spelled out, so it does
- * not count -- matching `applyOffset`, which is likewise a no-op for it.
- */
-function hasExplicitOffset(annotation: TextAnnotation): boolean {
-  const moved = (annotation.offset?.dx ?? 0) !== 0 || (annotation.offset?.dy ?? 0) !== 0;
-  return moved && !isAutoPlacement(annotation);
-}
-
-/**
- * Try to reposition a text annotation to avoid overlapping with obstacle rects
- * (legend bounds, etc.). First tries standard anchor alternatives, then
- * calculates specific offsets needed to clear obstacles. Returns true if moved.
- */
-export function nudgeAnnotationFromObstacles(
-  annotation: ResolvedAnnotation,
-  originalAnnotation: TextAnnotation,
-  scales: ResolvedScales,
-  chartArea: Rect,
-  obstacles: Rect[],
-  measure: AnnotationMeasureTextFn = heuristicMeasure,
-): boolean {
-  if (annotation.type !== 'text' || !annotation.label) return false;
-
-  // An `offset` is the author stating where the block goes. Auto-avoidance is for
-  // annotations that didn't say. Nudging one anyway makes the offset behave like a
-  // suggestion the engine is free to ignore: on a line chart the polyline is one
-  // long obstacle, so `dy: -10` moved a right-anchored block by *zero* pixels and
-  // `dy: -15` teleported it 56px. Same knob, no monotonicity -- unauthorable.
-  if (hasExplicitOffset(originalAnnotation)) return false;
-
-  const label = annotation.label;
-  const bounds = annotation.bounds ?? annotationBlockBounds(annotation, label, measure);
-  const collidingObs = obstacles.filter(
-    (obs) => obs.width > 0 && obs.height > 0 && detectCollision(bounds, obs),
-  );
-
-  if (collidingObs.length === 0) return false;
-
-  // A guard, not an input: the nudge geometry below comes from `bounds` and
-  // `connector.endpoint`, not from the data point. But an annotation whose
-  // position no longer resolves has nothing to anchor a connector to, so refuse
-  // to move it rather than shift a label away from a point we can't locate.
-  if (
-    resolvePosition(originalAnnotation.x, scales.x) === null ||
-    resolvePosition(originalAnnotation.y, scales.y) === null
-  ) {
-    return false;
-  }
-
-  const candidates = generateNudgeCandidates(bounds, collidingObs, NUDGE_PADDING);
-  // Read the size off the label, don't back-derive it from the box: `bounds` is
-  // the label ∪ subtitle union, so dividing its height by the *primary* line
-  // count returns roughly double the real size on a subtitled annotation, which
-  // silently doubles the margin slop below.
-  const fontSize = label.style.fontSize ?? DEFAULT_ANNOTATION_FONT_SIZE;
-
-  // A drop-line is a vertical rule running DOWN from the block to the point. Nudge
-  // the block below its own endpoint and the line inverts: it points up, away from
-  // the data, and the block covers the mark it was labelling. The resolver already
-  // placed it (side auto-flip, clamp against the chart top), so the only nudges
-  // worth taking are ones that keep it overhead.
-  const dropLineEndpointY =
-    label.connector?.style === 'drop-line' ? label.connector.endpoint?.y : undefined;
-
-  for (const { dx, dy } of candidates) {
-    const candidateBounds: Rect = { ...bounds, x: bounds.x + dx, y: bounds.y + dy };
-
-    if (
-      dropLineEndpointY !== undefined &&
-      candidateBounds.y + candidateBounds.height > dropLineEndpointY
-    ) {
-      continue;
-    }
-
-    // Check no collisions with any obstacle
-    const stillCollides = obstacles.some(
-      (obs) => obs.width > 0 && obs.height > 0 && detectCollision(candidateBounds, obs),
-    );
-    if (stillCollides) continue;
-
-    // Annotations render outside the clip path, so they can extend into margins.
-    // Only check that the label center is reasonably within the chart and that
-    // the text doesn't go completely off-screen.
-    const labelCenterX = candidateBounds.x + candidateBounds.width / 2;
-    const labelCenterY = candidateBounds.y + candidateBounds.height / 2;
-    // Allow nudged labels to extend into the chrome region below the chart
-    // (source/footer area) since annotations near the bottom edge often
-    // need to shift into that space to avoid marks or the brand watermark.
-    const inBounds =
-      labelCenterX >= chartArea.x &&
-      labelCenterX <= chartArea.x + chartArea.width + 10 &&
-      labelCenterY >= chartArea.y - fontSize &&
-      labelCenterY <= chartArea.y + chartArea.height + fontSize * 3;
-
-    if (inBounds) {
-      moveAnnotationBy(annotation, label, dx, dy, measure);
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Resolve collisions between text annotation labels using a greedy algorithm.
- *
- * Iterates through text annotations in order, building a list of "placed"
- * bounding rects. When a later annotation overlaps an already-placed one,
- * it tries offset positions (below, above, left, right) to find a
- * non-colliding spot. Recomputes the connector after nudging.
- */
-export function resolveAnnotationCollisions(
-  annotations: ResolvedAnnotation[],
-  originalSpecs: NormalizedChartSpec['annotations'],
-  scales: ResolvedScales,
-  chartArea: Rect,
-  measure: AnnotationMeasureTextFn = heuristicMeasure,
-  /**
-   * Predicate on the index into `annotations`: true for an auto-placed entry.
-   *
-   * The scored placement pass already positioned those to avoid everything, so
-   * they must not be nudged again — but they still occupy space, so they stay in
-   * `placedBounds` and the explicit annotations avoid them. Callers pass the full
-   * annotation list; nobody hand-builds a filtered copy, because a second
-   * representation of the list is what breaks `specIndex` lookups.
-   */
-  isAutoPlaced?: (index: number) => boolean,
-): void {
-  /** Immovable here: sited by the scored search, or hand-placed by the author. */
-  const isPinned = (annotation: ResolvedAnnotation, i: number): boolean => {
-    if (isAutoPlaced?.(i)) return true;
-    // `annotations` is a filtered view of `originalSpecs` -- an annotation that
-    // failed to resolve was dropped -- so index by the stamped spec index, not
-    // by position here. Falling back to `i` keeps a hand-built layout working.
-    const spec = originalSpecs[annotation.specIndex ?? i];
-    return spec?.type === 'text' && hasExplicitOffset(spec);
-  };
-
-  const isText = (a: ResolvedAnnotation) => a.type === 'text' && !!a.label;
-
-  // Seed with EVERY pinned block before nudging anything.
-  //
-  // This used to be one forward sweep that pushed a pinned block's bounds when it
-  // reached it. That only lets annotations authored *after* a pinned one route
-  // around it -- everything earlier was nudged against a `placedBounds` that did not
-  // contain it yet, so "the pinned block claims its space" held or failed purely on
-  // spec order, and two callouts on the same point printed on top of each other when
-  // the pinned one happened to be listed second.
-  const placedBounds: Rect[] = [];
-  for (let i = 0; i < annotations.length; i++) {
-    const annotation = annotations[i];
-    if (!isText(annotation) || !isPinned(annotation, i)) continue;
-    placedBounds.push(
-      annotation.bounds ?? annotationBlockBounds(annotation, annotation.label!, measure),
-    );
-  }
-
-  for (let i = 0; i < annotations.length; i++) {
-    const annotation = annotations[i];
-    if (!isText(annotation) || isPinned(annotation, i)) continue;
-
-    const label = annotation.label!;
-    const bounds = annotation.bounds ?? annotationBlockBounds(annotation, label, measure);
-    const originalSpec = originalSpecs[annotation.specIndex ?? i];
-
-    // Check against all previously placed annotation blocks
-    const collidingBounds = placedBounds.filter(
-      (pb) => pb.width > 0 && pb.height > 0 && detectCollision(bounds, pb),
-    );
-
-    if (collidingBounds.length > 0) {
-      if (originalSpec?.type === 'text') {
-        // A guard, not an input: same as in nudgeAnnotationFromObstacles, the
-        // geometry below comes from `bounds` and `connector.endpoint`. Refuse to
-        // move a label whose data point we can no longer locate.
-        const px = resolvePosition(originalSpec.x, scales.x);
-        const py = resolvePosition(originalSpec.y, scales.y);
-
-        if (px !== null && py !== null) {
-          const candidates = generateNudgeCandidates(bounds, collidingBounds, NUDGE_PADDING);
-          // Read the size off the label, don't back-derive it from the box: `bounds` is
-          // the label ∪ subtitle union, so dividing its height by the *primary* line
-          // count returns roughly double the real size on a subtitled annotation, which
-          // silently doubles the margin slop below.
-          const fontSize = label.style.fontSize ?? DEFAULT_ANNOTATION_FONT_SIZE;
-
-          for (const { dx, dy } of candidates) {
-            const candidateBounds: Rect = { ...bounds, x: bounds.x + dx, y: bounds.y + dy };
-
-            // Check no collisions with any placed block
-            const stillCollides = placedBounds.some(
-              (pb) => pb.width > 0 && pb.height > 0 && detectCollision(candidateBounds, pb),
-            );
-            if (stillCollides) continue;
-
-            // Check the label center stays reasonably in bounds
-            const labelCenterX = candidateBounds.x + candidateBounds.width / 2;
-            const labelCenterY = candidateBounds.y + candidateBounds.height / 2;
-            const inBounds =
-              labelCenterX >= chartArea.x &&
-              labelCenterX <= chartArea.x + chartArea.width + 10 &&
-              labelCenterY >= chartArea.y - fontSize &&
-              labelCenterY <= chartArea.y + chartArea.height + fontSize;
-
-            if (inBounds) {
-              moveAnnotationBy(annotation, label, dx, dy, measure);
-              break;
-            }
-          }
-        }
-      }
-    }
-
-    // Add this annotation's final bounds to the placed list
-    placedBounds.push(annotation.bounds ?? annotationBlockBounds(annotation, label, measure));
-  }
-}
-
-/**
- * Shift text annotation labels so they stay within the total SVG bounds.
- * If a label overflows the right, left, top, or bottom edge, its position
- * is adjusted inward by the overflow amount. Connector geometry is updated
- * to match.
- */
-export function clampAnnotationsToBounds(
-  annotations: ResolvedAnnotation[],
-  svgWidth: number,
-  svgHeight: number,
-  measure: AnnotationMeasureTextFn = heuristicMeasure,
-): void {
-  for (const annotation of annotations) {
-    if (annotation.type !== 'text' || !annotation.label) continue;
-
-    const label = annotation.label;
-    const bounds = annotation.bounds ?? annotationBlockBounds(annotation, label, measure);
-    let dx = 0;
-    let dy = 0;
-
-    // Right overflow
-    if (bounds.x + bounds.width > svgWidth - CLAMP_MARGIN) {
-      dx = svgWidth - CLAMP_MARGIN - (bounds.x + bounds.width);
-    }
-    // Left overflow
-    if (bounds.x + dx < CLAMP_MARGIN) {
-      dx = CLAMP_MARGIN - bounds.x;
-    }
-    // Top overflow
-    if (bounds.y < CLAMP_MARGIN) {
-      dy = CLAMP_MARGIN - bounds.y;
-    }
-    // Bottom overflow
-    if (bounds.y + bounds.height + dy > svgHeight - CLAMP_MARGIN) {
-      dy = svgHeight - CLAMP_MARGIN - (bounds.y + bounds.height);
-    }
-
-    if (dx === 0 && dy === 0) continue;
-
-    moveAnnotationBy(annotation, label, dx, dy, measure);
-  }
-}

package/src/annotations/compute.ts

@@ -1,333 +0,0 @@
-/**
- * Annotation computation: converts spec-level annotations to pixel-positioned
- * ResolvedAnnotation objects using the resolved scales.
- *
- * Handles three annotation types:
- * - text: positioned at a data coordinate with an optional callout
- * - range: a highlighted rectangle between two data values
- * - refline: a horizontal or vertical reference line at a data value
- *
- * Supports fine-grained positioning via offset, anchor, connector, and zIndex.
- * At compact breakpoints, annotations are simplified or hidden.
- */
-
-import type {
-  LayoutStrategy,
-  Rect,
-  ResolvedAnnotation,
-  TextAnnotation,
-} from '@opendata-ai/openchart-core';
-import type { NormalizedChartSpec } from '../compiler/types';
-import type { ResolvedScales } from '../layout/scales';
-import {
-  clampAnnotationsToBounds,
-  nudgeAnnotationFromObstacles,
-  resolveAnnotationCollisions,
-} from './collisions';
-import { SUBTITLE_FONT_WEIGHT, subtitleFontSize } from './constants';
-import type { AnnotationMeasureTextFn } from './geometry';
-import { heuristicMeasure } from './geometry';
-import { moveAnnotationTo } from './move';
-import {
-  findBestPlacement,
-  isAutoPlacement,
-  normalizeObstacles,
-  type PlacementObstacle,
-} from './placement';
-import { resolvePosition } from './position';
-import { resolveRangeAnnotation } from './resolve-range';
-import { resolveRefLineAnnotation } from './resolve-refline';
-import {
-  makeAnnotationLabelStyle,
-  resolveLedeFontWeight,
-  resolveTextAnnotation,
-} from './resolve-text';
-
-export interface AnnotationContext {
-  scales: ResolvedScales;
-  chartArea: Rect;
-  strategy: LayoutStrategy;
-  isDark: boolean;
-  obstacles: PlacementObstacle[];
-  svg: { width: number; height: number };
-  measure: AnnotationMeasureTextFn;
-  /** Theme font stack, so annotation text is measured and rendered in the same face. */
-  fontFamily?: string;
-  debugPlacement?: boolean;
-  /** When true, annotations that overlap are demoted to footnote markers instead of being hidden. */
-  autoThin?: boolean;
-}
-
-/**
- * Compute resolved annotations from spec annotations using the resolved scales.
- *
- * Converts data-coordinate annotations to pixel-positioned ResolvedAnnotation
- * objects. Supports offset, anchor, connector, and zIndex. At compact
- * breakpoints, annotations are hidden (strategy says "tooltip-only").
- *
- * When obstacle rects are provided (e.g. legend bounds), text annotations
- * that overlap with them are automatically repositioned using alternate
- * anchor directions. After individual obstacle avoidance, annotation-to-
- * annotation collisions are resolved using a greedy placement algorithm.
- * Finally, labels are clamped to stay within the total SVG bounds.
- */
-export function computeAnnotations(
-  spec: NormalizedChartSpec,
-  ctx: AnnotationContext,
-): ResolvedAnnotation[];
-
-/**
- * @deprecated Use the context-object overload instead.
- */
-export function computeAnnotations(
-  spec: NormalizedChartSpec,
-  scales: ResolvedScales,
-  chartArea: Rect,
-  strategy: LayoutStrategy,
-  isDark?: boolean,
-  obstacles?: Rect[],
-  svgDimensions?: { width: number; height: number },
-): ResolvedAnnotation[];
-
-export function computeAnnotations(
-  spec: NormalizedChartSpec,
-  scalesOrCtx: ResolvedScales | AnnotationContext,
-  chartArea?: Rect,
-  strategy?: LayoutStrategy,
-  isDark?: boolean,
-  obstacles?: Rect[],
-  svgDimensions?: { width: number; height: number },
-): ResolvedAnnotation[] {
-  let ctx: AnnotationContext;
-
-  if ('measure' in scalesOrCtx) {
-    ctx = scalesOrCtx as AnnotationContext;
-  } else {
-    ctx = {
-      scales: scalesOrCtx as ResolvedScales,
-      chartArea: chartArea!,
-      strategy: strategy!,
-      isDark: isDark ?? false,
-      obstacles: obstacles ? normalizeObstacles(obstacles) : [],
-      svg: svgDimensions ?? { width: 0, height: 0 },
-      measure: heuristicMeasure,
-    };
-  }
-
-  const isCompact = ctx.strategy.annotationPosition === 'tooltip-only' && !ctx.autoThin;
-
-  const svgRect: Rect = { x: 0, y: 0, width: ctx.svg.width, height: ctx.svg.height };
-  const annotations: ResolvedAnnotation[] = [];
-
-  // Deferred auto-placement entries (resolved in Pass 2)
-  const autoQueue: Array<{
-    annotation: TextAnnotation;
-    anchorX: number;
-    anchorY: number;
-    resolved: ResolvedAnnotation;
-    index: number;
-  }> = [];
-
-  // ---- Pass 1: resolve explicit annotations and queue auto ones ----
-  for (const [specIndex, annotation] of spec.annotations.entries()) {
-    if (isCompact && annotation.responsive !== false) {
-      continue;
-    }
-    let resolved: ResolvedAnnotation | null = null;
-
-    switch (annotation.type) {
-      case 'text':
-        resolved = resolveTextAnnotation(
-          annotation,
-          ctx.scales,
-          ctx.chartArea,
-          ctx.isDark,
-          ctx.measure,
-          ctx.fontFamily,
-        );
-        if (resolved && ctx.svg.width > 0 && ctx.svg.height > 0 && isAutoPlacement(annotation)) {
-          const px = resolvePosition(annotation.x, ctx.scales.x);
-          const py = resolvePosition(annotation.y, ctx.scales.y);
-          if (px !== null && py !== null) {
-            autoQueue.push({
-              annotation,
-              anchorX: px,
-              anchorY: py,
-              resolved,
-              index: annotations.length,
-            });
-            // Same contract as the push below -- this branch `continue`s past it.
-            resolved.specIndex = specIndex;
-            annotations.push(resolved);
-            continue;
-          }
-        }
-        break;
-      case 'range':
-        resolved = resolveRangeAnnotation(
-          annotation,
-          ctx.scales,
-          ctx.chartArea,
-          ctx.isDark,
-          ctx.fontFamily,
-        );
-        break;
-      case 'refline':
-        resolved = resolveRefLineAnnotation(
-          annotation,
-          ctx.scales,
-          ctx.chartArea,
-          ctx.isDark,
-          ctx.fontFamily,
-        );
-        break;
-    }
-
-    if (resolved) {
-      if (annotation.type === 'text' && ctx.obstacles.length > 0) {
-        nudgeAnnotationFromObstacles(
-          resolved,
-          annotation,
-          ctx.scales,
-          ctx.chartArea,
-          ctx.obstacles,
-          ctx.measure,
-        );
-      }
-      // The resolved array is filtered (an out-of-domain annotation resolves to
-      // nothing), so carry the spec index along -- it's the only stable way back
-      // to the authored annotation from here on.
-      resolved.specIndex = specIndex;
-      annotations.push(resolved);
-    }
-  }
-
-  // ---- Pass 2: scored placement search for auto annotations ----
-  if (autoQueue.length > 0 && ctx.svg.width > 0 && ctx.svg.height > 0) {
-    // Build the working obstacle list: base obstacles + explicitly placed annotations
-    const workingObstacles: PlacementObstacle[] = [...ctx.obstacles];
-    for (let i = 0; i < annotations.length; i++) {
-      const a = annotations[i];
-      if (a.bounds && !autoQueue.some((q) => q.index === i)) {
-        workingObstacles.push({ ...a.bounds, kind: 'annotation' } as PlacementObstacle);
-      }
-    }
-
-    for (const entry of autoQueue) {
-      const { annotation, anchorX, anchorY, resolved } = entry;
-      // Must mirror resolveTextAnnotation exactly (lede weight, theme font):
-      // findBestPlacement measures with this style, and the resolved annotation
-      // renders with the other one. Any drift and the scored bounds are a lie.
-      const labelStyle = makeAnnotationLabelStyle(
-        annotation.fontSize,
-        resolveLedeFontWeight(annotation),
-        undefined,
-        ctx.isDark,
-        ctx.fontFamily,
-      );
-
-      const subtitleStyle = annotation.subtitle
-        ? {
-            fontSize: subtitleFontSize(labelStyle.fontSize),
-            fontWeight: SUBTITLE_FONT_WEIGHT,
-            lineHeight: labelStyle.lineHeight,
-            fontFamily: labelStyle.fontFamily,
-          }
-        : undefined;
-
-      const result = findBestPlacement(
-        anchorX,
-        anchorY,
-        annotation.text,
-        {
-          fontSize: labelStyle.fontSize,
-          fontWeight: Number(labelStyle.fontWeight) || 400,
-          lineHeight: labelStyle.lineHeight,
-          fontFamily: labelStyle.fontFamily,
-        },
-        annotation.subtitle,
-        subtitleStyle,
-        workingObstacles,
-        ctx.chartArea,
-        svgRect,
-        ctx.measure,
-        ctx.debugPlacement,
-      );
-
-      // Commit the placement. `moveAnnotationTo` owns every piece of the block's
-      // geometry -- label, subtitle, both bounds caches, connector -- so this pass
-      // does not get to invent its own copy of any of them. It used to, and the
-      // copies drifted: this one re-derived the subtitle's baseline from a font-metric
-      // sum spelled `+ 2` while the resolver spelled it `SUBTITLE_GAP`, so a subtitled
-      // callout rendered 3px off from where the search had actually scored it.
-      if (resolved.label) {
-        moveAnnotationTo(
-          resolved,
-          resolved.label,
-          result.labelX,
-          result.labelY,
-          ctx.measure,
-          result.textAnchor,
-        );
-      }
-
-      // Add this annotation's bounds as obstacle for subsequent auto annotations.
-      // Read it back off the annotation rather than reusing `result.bounds`: the
-      // mover is the authority on the block's extent, and `result.bounds` is the
-      // search's own estimate of it. One of them has to be the source of truth.
-      const placedBounds = resolved.bounds ?? result.bounds;
-      workingObstacles.push({ ...placedBounds, kind: 'annotation' } as PlacementObstacle);
-    }
-  } else if (autoQueue.length > 0) {
-    // Fallback: no SVG dimensions, use legacy nudge for auto annotations
-    for (const entry of autoQueue) {
-      if (ctx.obstacles.length > 0) {
-        nudgeAnnotationFromObstacles(
-          entry.resolved,
-          entry.annotation,
-          ctx.scales,
-          ctx.chartArea,
-          ctx.obstacles,
-          ctx.measure,
-        );
-      }
-    }
-  }
-
-  // Resolve annotation-to-annotation collisions for non-auto-placed annotations.
-  // When auto placement ran, those annotations already avoid each other via the
-  // obstacle-accumulation loop above, so only explicitly placed ones need this.
-  //
-  // There used to be a hand-rolled walk here that built a *compacted* pair of
-  // arrays (explicit annotations + their specs) and passed those. It was the
-  // second representation of the same list, and once `resolveAnnotationCollisions`
-  // started keying on the stamped `specIndex` — a GLOBAL index — the compacted
-  // spec array no longer matched it. Every lookup was off by the number of auto
-  // annotations, and the `type === 'text'` guard swallowed the resulting
-  // `undefined`, so collision avoidance silently did nothing the moment a single
-  // auto-placed annotation was present. Which is the *encouraged* authoring style:
-  // a bare `{ type: 'text' }` is auto-placed by definition.
-  //
-  // So don't rebuild the list. Pass the real one, and let the pass skip the
-  // auto-placed entries itself — `specIndex` already tells it which spec each
-  // resolved annotation came from.
-  const autoIndices = new Set(autoQueue.map((q) => q.index));
-  resolveAnnotationCollisions(
-    annotations,
-    spec.annotations,
-    ctx.scales,
-    ctx.chartArea,
-    ctx.measure,
-    autoQueue.length > 0 ? (i) => autoIndices.has(i) : undefined,
-  );
-
-  // Clamp labels that overflow the SVG boundary back inside
-  if (ctx.svg.width > 0 && ctx.svg.height > 0) {
-    clampAnnotationsToBounds(annotations, ctx.svg.width, ctx.svg.height, ctx.measure);
-  }
-
-  // Sort by zIndex (lower first, undefined treated as 0)
-  annotations.sort((a, b) => (a.zIndex ?? 0) - (b.zIndex ?? 0));
-
-  return annotations;
-}