@opendata-ai/openchart-engine 8.0.0-rc.8 → 8.0.0

package/src/annotations/constants.ts

@@ -1,162 +0,0 @@
-/** Default font size for annotation labels. */
-export const DEFAULT_ANNOTATION_FONT_SIZE = 13;
-
-/**
- * Default font weight for annotation labels. Regular, not bold: emphasis comes
- * from inline `**bold**` spans, per the NYT/Datawrapper voice.
- */
-export const DEFAULT_ANNOTATION_FONT_WEIGHT = 400;
-
-/**
- * Weight the primary text takes when a subtitle is present and the author set no
- * explicit `fontWeight` — the "Feb. 25 / 2015 maximum" lede + context stack.
- */
-export const LEDE_FONT_WEIGHT = 700;
-
-/** Subtitles are always regular, so they never inherit a lede weight. */
-export const SUBTITLE_FONT_WEIGHT = 400;
-
-/** Font stack used when the theme font isn't threaded through (SSR/legacy paths). */
-export const FALLBACK_FONT_FAMILY = 'Inter, system-ui, sans-serif';
-
-/** Default line height multiplier for annotation text. */
-export const DEFAULT_LINE_HEIGHT = 1.3;
-
-/** Default fill color for range annotations. */
-export const DEFAULT_RANGE_FILL = '#f0c040';
-
-/** Default opacity for range annotations. */
-export const DEFAULT_RANGE_OPACITY = 0.15;
-
-/** Default dash pattern for reference lines. */
-export const DEFAULT_REFLINE_DASH = '4 3';
-
-// Theme-aware defaults for text and stroke colors
-export const LIGHT_TEXT_FILL = '#333333';
-export const DARK_TEXT_FILL = '#d1d5db';
-export const LIGHT_REFLINE_STROKE = '#888888';
-export const DARK_REFLINE_STROKE = '#9ca3af';
-
-// Quiet connector voice: gray hairline leaders (non-arrowed straight, drop-line).
-// Arrowed connectors take the label's text ink instead, so the emphasis callout
-// reads as one gesture with the words.
-export const LIGHT_CONNECTOR_STROKE = '#8f8f8f';
-export const DARK_CONNECTOR_STROKE = '#9aa0a6';
-
-// Muted text fill for annotation subtitles (~60% perceived contrast vs primary)
-export const LIGHT_MUTED_TEXT_FILL = '#6b7280';
-export const DARK_MUTED_TEXT_FILL = '#9ca3af';
-
-// Background fills used as the default "open ring" dot interior
-export const LIGHT_DOT_FILL = '#ffffff';
-export const DARK_DOT_FILL = '#0a0a0a';
-
-// Surface fills for the text-annotation background plate (the mask that hides
-// chart lines behind label text). `background: true` resolves to these, so
-// authors don't hardcode '#ffffff' and get light-gray-on-white in dark mode.
-export const LIGHT_LABEL_BACKGROUND = '#ffffff';
-export const DARK_LABEL_BACKGROUND = '#0a0a0a';
-
-/** Default annotation dot radius in pixels. */
-export const DEFAULT_DOT_RADIUS = 4;
-
-/** Default annotation dot stroke width in pixels. */
-export const DEFAULT_DOT_STROKE_WIDTH = 1.5;
-
-/** Vertical gap (px) between the primary annotation text and its subtitle. */
-export const SUBTITLE_GAP = 2;
-
-/** Subtitle font size multiplier (relative to primary annotation font size). */
-export const SUBTITLE_FONT_SIZE_RATIO = 0.85;
-
-/**
- * The subtitle's resolved font size. Rounded, and shared by every caller: the
- * auto-placement pass measures the subtitle to score candidate bounds while the
- * resolver sets the size that actually renders. If one rounds and the other
- * doesn't (13 * 0.85 = 11.05 vs 11), the scored bounds are a lie and the drift
- * flows into collisions and thinning.
- */
-export function subtitleFontSize(primaryFontSize: number): number {
-  return Math.round(primaryFontSize * SUBTITLE_FONT_SIZE_RATIO);
-}
-
-/**
- * The subtitle's baseline, given the label's. Same contract as `subtitleFontSize`,
- * and shared for the same reason: the auto-placement pass SCORES a candidate
- * subtitle position and the resolver STAMPS the one that renders. Two copies of
- * this sum is two chances to disagree -- and they did, one spelling the gap
- * `SUBTITLE_GAP` and the other a bare `+ 2`.
- *
- * `primaryLineHeightPx` is the line's height in PIXELS, not the ratio -- so a caller
- * holding a ratio multiplies by the font size on the way in. Taking the two factors
- * separately meant the one caller that already had the product had to pass a magic
- * `1` for the font size, and a signature you have to outsmart is a signature that
- * will eventually be outsmarted wrong.
- */
-export function subtitleBaselineY(
-  labelY: number,
-  primaryLineHeightPx: number,
-  primaryLineCount: number,
-): number {
-  return labelY + primaryLineHeightPx * primaryLineCount + SUBTITLE_GAP;
-}
-
-/** Gap (px) between the label bounding box and the start of its connector. */
-export const CONNECTOR_STANDOFF = 6;
-
-/**
- * Connectors shorter than this are suppressed: a nub between a label and the
- * marker it's already touching reads as noise, not as a leader.
- *
- * Keep this well under the standoff + marker-pullback overhead (~18px), which
- * is spent before the line is drawn at all. Setting it near or above that
- * overhead makes the default annotation structurally unable to draw a
- * connector, however far the author offsets the label.
- */
-export const MIN_CONNECTOR_LENGTH = 8;
-
-/**
- * Arrowhead length along the tangent. The renderer pulls the connector's line end
- * back by exactly this much so the stroke stops at the open V instead of poking
- * through its tip — a hand-copied duplicate on the vanilla side would silently
- * drift the next time this changes.
- */
-export const ARROWHEAD_LENGTH = 7;
-
-/** Arrowhead half-width perpendicular to the tangent. */
-export const ARROWHEAD_HALF_WIDTH = 3.5;
-
-/**
- * Is a connector of this length worth drawing?
- *
- * An arrowed connector doesn't stroke its full length: the renderer stops the line
- * `ARROWHEAD_LENGTH` short and spends that budget on the head. So a bare
- * `length >= MIN_CONNECTOR_LENGTH` test is arrow-blind — an 8.1px arrowed
- * connector clears it, and then ships a 1.1px stub with an arrowhead stuck on the
- * end. The minimum has to be measured against the part that actually gets stroked,
- * which means the gate has to know about the head.
- *
- * Both suppression sites (`resolveTextAnnotation`, `refreshConnector`) call this
- * instead of comparing against the constant themselves.
- */
-export function connectorIsDrawable(length: number, arrow: boolean | undefined): boolean {
-  return length - (arrow ? ARROWHEAD_LENGTH : 0) >= MIN_CONNECTOR_LENGTH;
-}
-
-/**
- * Default label setback from the data point when using anchor directions.
- *
- * Sized so a bare `{ type: 'text' }` annotation lands clear of its marker and
- * draws a real leader with no offset authoring — a minimal spec should render
- * publication-ready. Authors tighten it with `offset`.
- */
-export const ANCHOR_OFFSET = 28;
-
-/** Vertical gap between the top of a drop-line and the top of its label box. */
-export const DROP_LINE_TOP_GAP = 4;
-
-/** Padding between annotation and obstacle when nudging. */
-export const NUDGE_PADDING = 6;
-
-/** Small inset margin so labels don't touch the SVG edge. */
-export const CLAMP_MARGIN = 4;

package/src/annotations/geometry.ts

@@ -1,376 +0,0 @@
-/**
- * Geometry utilities for annotation text bounds, connector origins, and offsets.
- */
-
-import type {
-  AnnotationAnchor,
-  AnnotationOffset,
-  Rect,
-  ResolvedLabel,
-} from '@opendata-ai/openchart-core';
-import { estimateTextWidth } from '@opendata-ai/openchart-core';
-import {
-  ANCHOR_OFFSET,
-  ARROWHEAD_HALF_WIDTH,
-  ARROWHEAD_LENGTH,
-  CONNECTOR_STANDOFF,
-  connectorIsDrawable,
-  DEFAULT_ANNOTATION_FONT_SIZE,
-  DEFAULT_ANNOTATION_FONT_WEIGHT,
-  DEFAULT_LINE_HEIGHT,
-  DROP_LINE_TOP_GAP,
-} from './constants';
-import { BOLD_SPAN_FONT_WEIGHT, parseAnnotationSpans } from './rich-text';
-
-/**
- * Measure one run of text at a given size and weight.
- *
- * Deliberately takes no `fontFamily`: neither implementation could use one.
- * `heuristicMeasure` below is family-blind, and the real canvas measurer gets its
- * family from the `createMeasureText(fontFamily)` closure, not per call -- so a
- * family passed here would be silently dropped while implying the opposite.
- * `style.fontFamily` on a *resolved label* is a different thing: that one is real
- * and gets rendered.
- */
-export type AnnotationMeasureTextFn = (
-  text: string,
-  font: { fontSize: number; fontWeight: number },
-) => number;
-
-export const heuristicMeasure: AnnotationMeasureTextFn = (text, { fontSize, fontWeight }) =>
-  estimateTextWidth(text, fontSize, fontWeight);
-
-/**
- * Width of one line of annotation text, `**bold**` spans included: each span is
- * measured at its own weight and the widths are summed. Measuring the raw string
- * would count the `**` markers and use one weight for the whole line, so bounds,
- * collisions, placement, and connector exits would all be wrong for rich text.
- */
-export function measureRichLine(
-  line: string,
-  style: { fontSize: number; fontWeight: number },
-  measure: AnnotationMeasureTextFn,
-): number {
-  const spans = parseAnnotationSpans(line);
-  let width = 0;
-  for (const span of spans) {
-    width += measure(span.text, {
-      fontSize: style.fontSize,
-      fontWeight: span.bold ? BOLD_SPAN_FONT_WEIGHT : style.fontWeight,
-    });
-  }
-  return width;
-}
-
-/**
- * Compute the bounding box of a text block, aware of textAnchor and multi-line layout.
- * labelY is the first-line baseline.
- */
-export function computeTextBlockBounds(
-  labelX: number,
-  labelY: number,
-  text: string,
-  style: {
-    fontSize: number;
-    fontWeight: number;
-    lineHeight: number;
-    textAnchor?: 'start' | 'middle' | 'end';
-    fontFamily?: string;
-  },
-  measure: AnnotationMeasureTextFn = heuristicMeasure,
-): Rect {
-  const lines = text.split('\n');
-  const maxWidth = Math.max(...lines.map((line) => measureRichLine(line, style, measure)));
-  const height =
-    style.fontSize + (lines.length - 1) * style.fontSize * style.lineHeight + style.fontSize * 0.3;
-
-  let x: number;
-  if (style.textAnchor === 'middle') {
-    x = labelX - maxWidth / 2;
-  } else if (style.textAnchor === 'end') {
-    x = labelX - maxWidth;
-  } else {
-    x = labelX;
-  }
-
-  return {
-    x,
-    y: labelY - style.fontSize,
-    width: maxWidth,
-    height,
-  };
-}
-
-export function unionRects(a: Rect, b: Rect): Rect {
-  const x = Math.min(a.x, b.x);
-  const y = Math.min(a.y, b.y);
-  return {
-    x,
-    y,
-    width: Math.max(a.x + a.width, b.x + b.width) - x,
-    height: Math.max(a.y + a.height, b.y + b.height) - y,
-  };
-}
-
-/**
- * Apply anchor direction to compute label offset from data point.
- * Returns { dx, dy } pixel offsets.
- */
-export function computeAnchorOffset(
-  anchor: AnnotationAnchor | undefined,
-  _px: number,
-  py: number,
-  chartArea: Rect,
-): { dx: number; dy: number } {
-  if (!anchor || anchor === 'auto') {
-    // Auto: place above if in the lower half, below if upper half
-    const isUpperHalf = py < chartArea.y + chartArea.height / 2;
-    return isUpperHalf
-      ? { dx: ANCHOR_OFFSET, dy: ANCHOR_OFFSET } // below-right
-      : { dx: ANCHOR_OFFSET, dy: -ANCHOR_OFFSET }; // above-right
-  }
-
-  switch (anchor) {
-    case 'top':
-      return { dx: 0, dy: -ANCHOR_OFFSET };
-    case 'bottom':
-      return { dx: 0, dy: ANCHOR_OFFSET };
-    case 'left':
-      return { dx: -ANCHOR_OFFSET, dy: 0 };
-    case 'right':
-      return { dx: ANCHOR_OFFSET, dy: 0 };
-  }
-}
-
-/** Apply user offset on top of computed anchor offset. */
-export function applyOffset(
-  base: { dx: number; dy: number },
-  offset: AnnotationOffset | undefined,
-): { dx: number; dy: number } {
-  if (!offset) return base;
-  return {
-    dx: base.dx + (offset.dx ?? 0),
-    dy: base.dy + (offset.dy ?? 0),
-  };
-}
-
-/** Inflation applied to the label box before intersecting the connector ray. */
-const BOX_INFLATE = 2;
-
-/**
- * Compute where a connector leaves the annotation's text block on its way to the
- * target. Casts a ray from the box center toward the target, intersects the
- * (slightly inflated) box, then advances `standoff` px along the ray so the line
- * never touches the glyphs.
- *
- * Returns `null` when the target sits inside the inflated box (a connector would
- * cross its own text) or when the standoff would overshoot the target.
- */
-export function connectorExit(
-  bounds: Rect,
-  targetX: number,
-  targetY: number,
-  standoff = CONNECTOR_STANDOFF,
-): { x: number; y: number; exit: 'horizontal' | 'vertical' } | null {
-  const box = {
-    x: bounds.x - BOX_INFLATE,
-    y: bounds.y - BOX_INFLATE,
-    width: bounds.width + BOX_INFLATE * 2,
-    height: bounds.height + BOX_INFLATE * 2,
-  };
-  const cx = box.x + box.width / 2;
-  const cy = box.y + box.height / 2;
-  const halfW = box.width / 2;
-  const halfH = box.height / 2;
-
-  const dx = targetX - cx;
-  const dy = targetY - cy;
-
-  // Target inside the inflated box: any connector would cross the text.
-  if (Math.abs(dx) <= halfW && Math.abs(dy) <= halfH) return null;
-  if (dx === 0 && dy === 0) return null;
-
-  // Parametric ray: center + t * (dx, dy). Find the smallest t that lands on an
-  // edge of the box, and which axis that edge belongs to.
-  const tx = halfW > 0 && dx !== 0 ? halfW / Math.abs(dx) : Number.POSITIVE_INFINITY;
-  const ty = halfH > 0 && dy !== 0 ? halfH / Math.abs(dy) : Number.POSITIVE_INFINITY;
-  const t = Math.min(tx, ty);
-  if (!Number.isFinite(t)) return null;
-
-  const exit: 'horizontal' | 'vertical' = tx <= ty ? 'horizontal' : 'vertical';
-
-  const edgeX = cx + dx * t;
-  const edgeY = cy + dy * t;
-
-  // Advance along the ray by the standoff distance.
-  const rayLen = Math.sqrt(dx * dx + dy * dy);
-  const ux = dx / rayLen;
-  const uy = dy / rayLen;
-
-  // Overshoot guard: the standoff must not push the origin past the target.
-  // Measure edge-to-target in pixels rather than scaling the ray by (1 - t):
-  // t is a ratio of box extents, so that form understates the clearance when the
-  // ray leaves through the long side of a wide label, and killed connectors that
-  // had ample room. Whether the line is long enough to be worth drawing is
-  // decided downstream against MIN_CONNECTOR_LENGTH, once the marker pullback is
-  // known — this guard only rejects a standoff that would overshoot the target.
-  const edgeToTarget = Math.hypot(targetX - edgeX, targetY - edgeY);
-  if (standoff >= edgeToTarget) return null;
-
-  const x = edgeX + ux * standoff;
-  const y = edgeY + uy * standoff;
-
-  return { x, y, exit };
-}
-
-/** Estimate the bounding box of an annotation label using its resolved style. */
-export function estimateLabelBounds(
-  label: ResolvedLabel,
-  measure: AnnotationMeasureTextFn = heuristicMeasure,
-): Rect {
-  const fontSize = label.style.fontSize ?? DEFAULT_ANNOTATION_FONT_SIZE;
-  const fontWeight = label.style.fontWeight ?? DEFAULT_ANNOTATION_FONT_WEIGHT;
-  return computeTextBlockBounds(
-    label.x,
-    label.y,
-    label.text,
-    {
-      fontSize,
-      fontWeight,
-      lineHeight: label.style.lineHeight ?? DEFAULT_LINE_HEIGHT,
-      textAnchor: label.style.textAnchor ?? 'start',
-      fontFamily: label.style.fontFamily,
-    },
-    measure,
-  );
-}
-
-/** Arrowhead triangle points: tip + two base corners. */
-export interface ArrowheadPoints {
-  tip: { x: number; y: number };
-  baseLeft: { x: number; y: number };
-  baseRight: { x: number; y: number };
-}
-
-// Both live in `constants.ts` (the min-length gate has to reason about the
-// arrowhead's stroke budget, and constants.ts can't import from here without a
-// cycle). Re-exported so the renderer's import path doesn't move.
-export { ARROWHEAD_HALF_WIDTH, ARROWHEAD_LENGTH };
-
-/**
- * Compute arrowhead triangle geometry at a connector endpoint.
- * Returns the tip (at the endpoint) and two base corners perpendicular to the
- * tangent direction.
- *
- * @param tipX - X coordinate of the arrowhead tip
- * @param tipY - Y coordinate of the arrowhead tip
- * @param tangentX - X component of the tangent direction (toward the tip)
- * @param tangentY - Y component of the tangent direction (toward the tip)
- * @param length - Arrow length along the tangent (default ARROWHEAD_LENGTH)
- * @param halfWidth - Arrow half-width perpendicular to tangent (default ARROWHEAD_HALF_WIDTH)
- */
-export function computeArrowheadPoints(
-  tipX: number,
-  tipY: number,
-  tangentX: number,
-  tangentY: number,
-  length = ARROWHEAD_LENGTH,
-  halfWidth = ARROWHEAD_HALF_WIDTH,
-): ArrowheadPoints {
-  const tLen = Math.sqrt(tangentX * tangentX + tangentY * tangentY) || 1;
-  const ux = tangentX / tLen;
-  const uy = tangentY / tLen;
-
-  const baseX = tipX - ux * length;
-  const baseY = tipY - uy * length;
-
-  const px = -uy;
-  const py = ux;
-
-  return {
-    tip: { x: tipX, y: tipY },
-    baseLeft: { x: baseX + px * halfWidth, y: baseY + py * halfWidth },
-    baseRight: { x: baseX - px * halfWidth, y: baseY - py * halfWidth },
-  };
-}
-
-/**
- * Distance the connector's data-point end is pulled back so the line stops short
- * of the endpoint marker instead of piercing it.
- */
-export function connectorPullbackGap(markerRadius: number, arrow: boolean): number {
-  return arrow ? Math.max(markerRadius + 2, 2) : Math.max(markerRadius + 3, 4);
-}
-
-/**
- * Rebuild a connector's geometry against a (possibly moved) annotation bounds.
- *
- * `from` comes from the ray-box exit; `to` is recomputed by pulling back from
- * `connector.endpoint` — never from the already-pulled-back `to`, which would
- * shrink the line a little more on every pass.
- *
- * Returns `undefined` when the connector should be suppressed: the target sits
- * inside the text block, or the resulting line is shorter than
- * `MIN_CONNECTOR_LENGTH`.
- */
-export function refreshConnector(
-  connector: NonNullable<ResolvedLabel['connector']>,
-  bounds: Rect,
-  markerRadius: number,
-): ResolvedLabel['connector'] {
-  // `endpoint` is the un-pulled-back data point, and the only valid basis for a
-  // rebuild: pulling back from `to` (already pulled back) shrinks the line a
-  // little more on every pass. Every resolver sets it, but the field is optional
-  // on the public `ResolvedLabel` type, so a layout from another producer could
-  // omit it — bail rather than silently compound the error.
-  if (!connector.endpoint) return undefined;
-  const endpoint = connector.endpoint;
-
-  // A drop-line is not a leader: it's a vertical rule pinned to the data point's
-  // x, running from just above the label box down to the marker. Rebuilding it
-  // from a ray-box exit tilts it into a diagonal (which the renderer draws with
-  // shape-rendering: crispEdges, assuming axis alignment), and the
-  // MIN_CONNECTOR_LENGTH rule below would delete it outright once the label sits
-  // near its point.
-  //
-  // This mirrors `resolveDropLineAnnotation`'s formula exactly — `from` above the
-  // label top, `to` pulled back from the point — so a nudged drop-line keeps the
-  // same geometry it resolved with, just at the label's new position.
-  if (connector.style === 'drop-line') {
-    const gap = connectorPullbackGap(markerRadius, false);
-    return {
-      ...connector,
-      from: { x: endpoint.x, y: bounds.y - DROP_LINE_TOP_GAP },
-      to: { x: endpoint.x, y: endpoint.y - gap },
-      exit: 'vertical',
-    };
-  }
-
-  const exit = connectorExit(bounds, endpoint.x, endpoint.y);
-  if (!exit) return undefined;
-
-  // Re-apply the author's from-end nudge BEFORE the pullback, so the pullback
-  // direction is measured from the real origin -- exactly as
-  // `resolveTextAnnotation` does on first resolve.
-  const from = {
-    x: exit.x + (connector.fromOffset?.dx ?? 0),
-    y: exit.y + (connector.fromOffset?.dy ?? 0),
-  };
-
-  const gap = connectorPullbackGap(markerRadius, connector.arrow);
-  const cdx = endpoint.x - from.x;
-  const cdy = endpoint.y - from.y;
-  const dist = Math.sqrt(cdx * cdx + cdy * cdy);
-  const to =
-    dist > 0
-      ? { x: endpoint.x - (cdx / dist) * gap, y: endpoint.y - (cdy / dist) * gap }
-      : { ...endpoint };
-
-  // Min-length check runs AFTER the pullback: a near-degenerate line can flip
-  // direction once its end is pulled back, and checking first would miss it.
-  const lx = to.x - from.x;
-  const ly = to.y - from.y;
-  if (!connectorIsDrawable(Math.sqrt(lx * lx + ly * ly), connector.arrow)) return undefined;
-
-  return { ...connector, from, to, exit: exit.exit };
-}

package/src/annotations/move.ts

@@ -1,135 +0,0 @@
-/**
- * The single owner of "where a resolved annotation sits".
- *
- * WHY THIS MODULE EXISTS
- *
- * An annotation's position is not one number, it's five that have to agree: the
- * label origin, the subtitle origin (absolute, not relative), the label-only
- * bounds, the label-union-subtitle block bounds, and the connector endpoints. The
- * resolver establishes that agreement -- and then FOUR later passes re-position
- * the block (obstacle nudge, mutual-collision nudge, clamp-to-bounds, and the
- * auto-placement search). Every one of them has to re-establish all five.
- *
- * When two of those passes each did their own arithmetic, the two copies drifted:
- * one spelled the subtitle gap `SUBTITLE_GAP`, the other spelled it `+ 2`, and a
- * subtitled auto-placed callout rendered its second line 3px off from where the
- * search had scored it. That is the bug this module exists to make unrepresentable.
- *
- * So: nothing outside this file writes annotation geometry. `moveAnnotationTo`
- * (absolute) and `moveAnnotationBy` (delta) are the only doors, and they always
- * leave all five in agreement.
- */
-
-import type { Rect, ResolvedAnnotation, ResolvedLabel } from '@opendata-ai/openchart-core';
-import {
-  DEFAULT_ANNOTATION_FONT_SIZE,
-  DEFAULT_LINE_HEIGHT,
-  SUBTITLE_FONT_WEIGHT,
-  subtitleFontSize,
-} from './constants';
-import {
-  type AnnotationMeasureTextFn,
-  computeTextBlockBounds,
-  estimateLabelBounds,
-  refreshConnector,
-  unionRects,
-} from './geometry';
-import { markerClearance } from './resolve-text';
-
-/**
- * The full block an annotation occupies: label text plus its subtitle.
- *
- * This is the box other annotations must avoid, and the box the connector exits.
- * It is NOT `label.bounds` -- that one is label-only by contract, because the
- * renderer sizes the `background` plate from it and a subtitled annotation must
- * not get a plate sized to both lines.
- */
-export function annotationBlockBounds(
-  annotation: ResolvedAnnotation,
-  label: ResolvedLabel,
-  measure: AnnotationMeasureTextFn,
-): Rect {
-  const labelBounds = estimateLabelBounds(label, measure);
-  const sub = annotation.subtitle;
-  if (!sub) return labelBounds;
-
-  const subBounds = computeTextBlockBounds(
-    sub.x,
-    sub.y,
-    sub.text,
-    {
-      // Every resolver stamps all three, so these fallbacks are unreachable today.
-      // They still come from the constants: a hand-rolled `?? 10` here is a second
-      // definition of the subtitle's type, free to drift from the real one.
-      fontSize: sub.style.fontSize ?? subtitleFontSize(DEFAULT_ANNOTATION_FONT_SIZE),
-      fontWeight: Number(sub.style.fontWeight) || SUBTITLE_FONT_WEIGHT,
-      lineHeight: sub.style.lineHeight ?? DEFAULT_LINE_HEIGHT,
-      textAnchor: sub.style.textAnchor ?? 'start',
-    },
-    measure,
-  );
-  return unionRects(labelBounds, subBounds);
-}
-
-/**
- * Put a resolved annotation's block at an absolute origin, keeping every piece of
- * its geometry in agreement.
- *
- * The subtitle is TRANSLATED with the label rather than re-derived from a font-metric
- * sum: the resolver already placed it correctly relative to the label, and a second
- * derivation here is a second chance to disagree with the first.
- *
- * `textAnchor` is optional because only the auto-placement search chooses a side;
- * the nudge passes slide a block that has already picked one.
- */
-export function moveAnnotationTo(
-  annotation: ResolvedAnnotation,
-  label: ResolvedLabel,
-  x: number,
-  y: number,
-  measure: AnnotationMeasureTextFn,
-  textAnchor?: 'start' | 'middle' | 'end',
-): void {
-  moveAnnotationBy(annotation, label, x - label.x, y - label.y, measure, textAnchor);
-}
-
-/**
- * Slide a resolved annotation's block by (dx, dy), keeping every piece of its
- * geometry in agreement. See `moveAnnotationTo`.
- */
-export function moveAnnotationBy(
-  annotation: ResolvedAnnotation,
-  label: ResolvedLabel,
-  dx: number,
-  dy: number,
-  measure: AnnotationMeasureTextFn,
-  textAnchor?: 'start' | 'middle' | 'end',
-): void {
-  const movedLabel: ResolvedLabel = { ...label, x: label.x + dx, y: label.y + dy };
-  if (textAnchor) {
-    movedLabel.style = { ...movedLabel.style, textAnchor };
-  }
-
-  if (annotation.subtitle) {
-    annotation.subtitle = {
-      ...annotation.subtitle,
-      x: annotation.subtitle.x + dx,
-      y: annotation.subtitle.y + dy,
-      ...(textAnchor ? { style: { ...annotation.subtitle.style, textAnchor } } : {}),
-    };
-  }
-
-  movedLabel.bounds = estimateLabelBounds(movedLabel, measure);
-  const blockBounds = annotationBlockBounds(annotation, movedLabel, measure);
-
-  if (movedLabel.connector) {
-    movedLabel.connector = refreshConnector(
-      movedLabel.connector,
-      blockBounds,
-      markerClearance(annotation.dot),
-    );
-  }
-
-  annotation.label = movedLabel;
-  annotation.bounds = blockBounds;
-}