@opendata-ai/openchart-engine 8.0.0-rc.2 → 8.0.0-rc.20

package/src/charts/column/index.ts

@@ -1,53 +0,0 @@
-/**
- * Column chart module (vertical bars).
- *
- * Exports the column chart renderer and computation functions.
- */
-
-import type { Mark } from '@opendata-ai/openchart-core';
-import { resolveFieldFormatter } from '../../format/field-format';
-import type { ChartRenderer } from '../registry';
-import { computeColumnMarks } from './compute';
-import { computeColumnLabels } from './labels';
-
-// ---------------------------------------------------------------------------
-// Column chart renderer
-// ---------------------------------------------------------------------------
-
-export const columnRenderer: ChartRenderer = (spec, scales, chartArea, strategy, theme) => {
-  const marks = computeColumnMarks(spec, scales, chartArea, strategy);
-
-  // Compute and attach value labels (respects spec.labels.density)
-  const valueField =
-    spec.encoding?.y && 'field' in spec.encoding.y ? spec.encoding.y.field : undefined;
-  const labelFormatter = resolveFieldFormatter({
-    surfaceFormat: spec.labels.format,
-    channelFormat:
-      spec.encoding?.y && 'format' in spec.encoding.y ? spec.encoding.y.format : undefined,
-    values: valueField ? spec.data.map((r) => r[valueField]) : [],
-  });
-  const labels = computeColumnLabels(
-    marks,
-    chartArea,
-    spec.labels.density,
-    labelFormatter,
-    spec.labels.prefix,
-    valueField,
-    spec.labels.color,
-    theme.isDark,
-    spec.labels.fontSize,
-    spec.labels.suffix,
-  );
-  for (let i = 0; i < marks.length && i < labels.length; i++) {
-    marks[i].label = labels[i];
-  }
-
-  return marks as Mark[];
-};
-
-// ---------------------------------------------------------------------------
-// Public exports
-// ---------------------------------------------------------------------------
-
-export { computeColumnMarks } from './compute';
-export { computeColumnLabels } from './labels';

package/src/charts/column/labels.ts

@@ -1,229 +0,0 @@
-/**
- * Column chart label computation.
- *
- * Produces value labels positioned above each column (for positive values)
- * or below (for negative values). Stacked segments are the exception: the
- * space above a segment's top edge belongs to the next segment up, not to the
- * background, so a stacked label is centered *inside* its own segment and
- * takes a contrasting fill (mirrors computeBarLabels).
- *
- * Respects the spec's label density setting:
- * - 'all': consider every column's label (no density pre-filter), but still
- *   run collision resolution so colliding losers are hidden rather than drawn
- *   on top of each other
- * - 'auto': existing behavior (density pre-filter + collision detection)
- * - 'endpoints': first and last columns only
- * - 'none': return empty array
- */
-
-import type {
-  LabelCandidate,
-  LabelDensity,
-  NumberFormatter,
-  RectMark,
-  ResolvedLabel,
-} from '@opendata-ai/openchart-core';
-import {
-  estimateTextWidth,
-  getRepresentativeColor,
-  pickLabelColor,
-  resolveCollisions,
-  textAscent,
-} from '@opendata-ai/openchart-core';
-import { filterByDensity } from '../_shared/density-filter';
-import { formatLabelValue } from '../_shared/format-label-value';
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const LABEL_FONT_SIZE = 10;
-const LABEL_FONT_WEIGHT = 600;
-const LABEL_OFFSET_Y = 8;
-/** Vertical padding inside a stacked segment, above and below the label. */
-const LABEL_PADDING_Y = 2;
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * Compute value labels for column marks.
- *
- * For each column, the value is placed centered above the column top.
- */
-export function computeColumnLabels(
-  marks: RectMark[],
-  _chartArea: { x: number; y: number; width: number; height: number },
-  density: LabelDensity = 'auto',
-  labelFormatter?: NumberFormatter | null,
-  labelPrefix?: string,
-  valueField?: string,
-  labelColor?: string,
-  darkMode = false,
-  fontSize?: number,
-  labelSuffix?: string,
-): ResolvedLabel[] {
-  const FONT_SIZE = fontSize ?? LABEL_FONT_SIZE;
-  const targetMarks = filterByDensity(marks, density);
-
-  const formatter = labelFormatter ?? null;
-
-  const candidates: LabelCandidate[] = [];
-  // Track whether each candidate fits inside its stacked segment. Non-stacked
-  // columns label into open space above the bar, so they always fit.
-  const fitsInSegment: boolean[] = [];
-
-  for (const mark of targetMarks) {
-    // Get the original numeric value from the data row when possible,
-    // falling back to parsing the aria label (which may lose precision
-    // due to abbreviation rounding, e.g. 1955 → "2K" → 2000).
-    let valuePart: string;
-    const rawNum = valueField != null ? Number(mark.data[valueField]) : NaN;
-
-    if (formatter && Number.isFinite(rawNum)) {
-      valuePart = formatter(rawNum);
-    } else if (Number.isFinite(rawNum)) {
-      valuePart = formatLabelValue(rawNum);
-    } else {
-      // Fallback: extract from aria label
-      const ariaLabel = mark.aria.label;
-      if (!ariaLabel) continue;
-      const lastColon = ariaLabel.lastIndexOf(':');
-      const rawValue = lastColon >= 0 ? ariaLabel.slice(lastColon + 1).trim() : '';
-      if (!rawValue) continue;
-      if (formatter) {
-        const num = Number(rawValue.replace(/[^0-9.-]/g, ''));
-        valuePart = !Number.isNaN(num) ? formatter(num) : rawValue;
-      } else {
-        valuePart = rawValue;
-      }
-    }
-    const numericValue = parseFloat(valuePart);
-    const isNegative = Number.isFinite(numericValue) && numericValue < 0;
-
-    if (labelPrefix) valuePart = labelPrefix + valuePart;
-    if (labelSuffix) valuePart = valuePart + labelSuffix;
-
-    const textWidth = estimateTextWidth(valuePart, FONT_SIZE, LABEL_FONT_WEIGHT);
-    const textHeight = FONT_SIZE * 1.2;
-
-    // A stacked segment has another segment sitting directly on top of it, so
-    // the "float above the top edge" placement used for plain columns would
-    // drop the label into its neighbour — and tint it with this segment's
-    // color, guaranteeing colored-text-on-colored-fill. Center it inside its
-    // own segment instead and pick a fill that contrasts with that segment.
-    const isStacked = mark.stackGroup !== undefined;
-
-    // anchorY is the TOP of the label bounding box so the collision system's
-    // AABB check (rect = { y: anchorY, height: textHeight }) is geometrically
-    // correct. Collision math stays in top-coordinate space; the ascent shift
-    // to the alphabetic baseline is applied only at emission (see below).
-    //   Stacked:      top = segment center - textHeight / 2, text sits within
-    //   Positive bar: top = barTop - LABEL_OFFSET_Y - textHeight, text floats above
-    //   Negative bar: top = barBottom + LABEL_OFFSET_Y, text hangs below
-    const anchorX = mark.x + mark.width / 2;
-    let anchorY: number;
-    let fill: string;
-
-    if (isStacked) {
-      anchorY = mark.y + mark.height / 2 - textHeight / 2;
-      fill = labelColor ?? pickLabelColor(getRepresentativeColor(mark.fill), darkMode);
-    } else {
-      anchorY = isNegative
-        ? mark.y + mark.height + LABEL_OFFSET_Y
-        : mark.y - LABEL_OFFSET_Y - textHeight;
-      fill = labelColor ?? getRepresentativeColor(mark.fill);
-    }
-
-    // A label only belongs inside a stacked segment if the segment is tall
-    // enough to hold it; short segments (Nuclear at ~4%) would otherwise
-    // overflow into their neighbours.
-    fitsInSegment.push(!(isStacked && textHeight > mark.height - 2 * LABEL_PADDING_Y));
-
-    candidates.push({
-      text: valuePart,
-      anchorX,
-      anchorY,
-      width: textWidth,
-      height: textHeight,
-      priority: 'data',
-      style: {
-        fontFamily: 'system-ui, -apple-system, sans-serif',
-        fontSize: FONT_SIZE,
-        fontWeight: LABEL_FONT_WEIGHT,
-        fill,
-        lineHeight: 1.2,
-        textAnchor: 'middle',
-        fontVariant: 'tabular-nums',
-      },
-    });
-  }
-
-  if (candidates.length === 0) return [];
-
-  // Collision resolution keeps y in top-edge coordinates; renderers position
-  // text on the alphabetic baseline, so shift every emitted y down by the
-  // ascent instead of relying on dominant-baseline:hanging (WebKit computes
-  // hanging from different font metrics than Blink, clipping labels on iOS).
-  const ascent = textAscent(FONT_SIZE);
-
-  // Every density that reaches here ('all' and 'auto') pre-hides candidates
-  // whose stacked segment is too short to hold them, then runs collision
-  // resolution. 'all' just skips the density pre-filter above so every mark is
-  // a candidate; colliding losers are still hidden by resolveCollisions rather
-  // than stacked on top of each other.
-  const fittingCandidates: LabelCandidate[] = [];
-  const unfittingIndices = new Set<number>();
-  for (let i = 0; i < candidates.length; i++) {
-    if (fitsInSegment[i] === false) {
-      unfittingIndices.add(i);
-    } else {
-      // Carry the original candidate index so we can zip the resolved output
-      // back to it regardless of any reordering resolveCollisions performs.
-      fittingCandidates.push({ ...candidates[i], index: i });
-    }
-  }
-
-  // resolveCollisions may reorder its output (it sorts by priority), so key the
-  // result by the source index we carried rather than by position.
-  const resolvedByOrig = new Map<number, ResolvedLabel>();
-  for (const r of resolveCollisions(fittingCandidates)) {
-    if (r.index !== undefined) resolvedByOrig.set(r.index, r);
-  }
-
-  // Re-emit hidden labels rather than dropping them: the renderer zips
-  // marks[i].label = labels[i], so the output must stay index-aligned.
-  const results: ResolvedLabel[] = [];
-  for (let i = 0; i < candidates.length; i++) {
-    if (unfittingIndices.has(i)) {
-      results.push({
-        text: candidates[i].text,
-        x: candidates[i].anchorX,
-        y: candidates[i].anchorY + ascent,
-        style: candidates[i].style,
-        visible: false,
-      });
-      continue;
-    }
-
-    const r = resolvedByOrig.get(i);
-    if (!r) continue;
-    // Drop the internal zip index so it doesn't leak into the label output.
-    const { index: _index, ...rest } = r;
-    results.push({
-      ...rest,
-      y: r.y + ascent,
-      // The connector originates at the label; shift its start to the baseline
-      // too so the leader stays glued to the shifted text.
-      connector: r.connector
-        ? {
-            ...r.connector,
-            from: { ...r.connector.from, y: r.connector.from.y + ascent },
-          }
-        : undefined,
-    });
-  }
-
-  return results;
-}

package/src/charts/dot/__tests__/compute.test.ts

@@ -1,380 +0,0 @@
-import type { LayoutStrategy, PointMark, Rect, RectMark } from '@opendata-ai/openchart-core';
-import { describe, expect, it } from 'vitest';
-import type { NormalizedChartSpec } from '../../../compiler/types';
-import { computeScales } from '../../../layout/scales';
-import { computeDotMarks } from '../compute';
-import { computeDotLabels } from '../labels';
-
-// ---------------------------------------------------------------------------
-// Shared fixtures
-// ---------------------------------------------------------------------------
-
-const chartArea: Rect = { x: 80, y: 20, width: 500, height: 300 };
-
-const fullStrategy: LayoutStrategy = {
-  labelMode: 'all',
-  legendPosition: 'right',
-  annotationPosition: 'inline',
-  axisLabelDensity: 'full',
-};
-
-function makeSimpleDotSpec(): NormalizedChartSpec {
-  return {
-    markType: 'circle',
-    markDef: { type: 'circle' },
-    data: [
-      { country: 'USA', score: 85 },
-      { country: 'UK', score: 72 },
-      { country: 'Japan', score: 90 },
-      { country: 'France', score: 68 },
-    ],
-    encoding: {
-      x: { field: 'score', type: 'quantitative' },
-      y: { field: 'country', type: 'nominal' },
-    },
-    chrome: {},
-    annotations: [],
-    responsive: true,
-    theme: {},
-    darkMode: 'off',
-    labels: { density: 'auto', format: '' },
-  };
-}
-
-function makeColoredDotSpec(): NormalizedChartSpec {
-  return {
-    markType: 'circle',
-    markDef: { type: 'circle' },
-    data: [
-      { item: 'Revenue', value: 120, status: 'good' },
-      { item: 'Costs', value: 80, status: 'neutral' },
-      { item: 'Profit', value: 40, status: 'good' },
-      { item: 'Debt', value: -10, status: 'bad' },
-    ],
-    encoding: {
-      x: { field: 'value', type: 'quantitative' },
-      y: { field: 'item', type: 'nominal' },
-      color: { field: 'status', type: 'nominal' },
-    },
-    chrome: {},
-    annotations: [],
-    responsive: true,
-    theme: {},
-    darkMode: 'off',
-    labels: { density: 'auto', format: '' },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// computeDotMarks tests
-// ---------------------------------------------------------------------------
-
-describe('computeDotMarks', () => {
-  describe('simple dot plot', () => {
-    it('produces PointMarks and RectMarks (stems)', () => {
-      const spec = makeSimpleDotSpec();
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-
-      const points = marks.filter((m): m is PointMark => m.type === 'point');
-      const stems = marks.filter((m): m is RectMark => m.type === 'rect');
-
-      expect(points).toHaveLength(4);
-      expect(stems).toHaveLength(4);
-    });
-
-    it('dot positions reflect data values (higher score = further right)', () => {
-      const spec = makeSimpleDotSpec();
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-
-      const points = marks.filter((m): m is PointMark => m.type === 'point');
-      const japan = points.find((m) => m.aria.label.includes('Japan'))!;
-      const france = points.find((m) => m.aria.label.includes('France'))!;
-
-      // Japan (90) should be further right than France (68)
-      expect(japan.cx).toBeGreaterThan(france.cx);
-    });
-
-    it('stems connect baseline to dot positions', () => {
-      const spec = makeSimpleDotSpec();
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-
-      const stems = marks.filter((m): m is RectMark => m.type === 'rect');
-      for (const stem of stems) {
-        expect(stem.width).toBeGreaterThan(0);
-        expect(stem.height).toBe(2); // STEM_WIDTH
-      }
-    });
-
-    it('dots are vertically centered within their band', () => {
-      const spec = makeSimpleDotSpec();
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-
-      const points = marks.filter((m): m is PointMark => m.type === 'point');
-      // All dots should be at different y positions (different categories)
-      const yPositions = points.map((p) => p.cy);
-      const uniqueY = new Set(yPositions);
-      expect(uniqueY.size).toBe(4);
-    });
-
-    it('dots have consistent radius', () => {
-      const spec = makeSimpleDotSpec();
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-
-      const points = marks.filter((m): m is PointMark => m.type === 'point');
-      const radii = new Set(points.map((p) => p.r));
-      expect(radii.size).toBe(1);
-    });
-
-    it('each dot has an aria label with category and value', () => {
-      const spec = makeSimpleDotSpec();
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-
-      const points = marks.filter((m): m is PointMark => m.type === 'point');
-      expect(points[0].aria.label).toContain('USA');
-      expect(points[0].aria.label).toContain('85');
-    });
-  });
-
-  describe('dumbbell (multi-series)', () => {
-    function makeDumbbellSpec(): NormalizedChartSpec {
-      return {
-        markType: 'circle',
-        markDef: { type: 'circle' },
-        data: [
-          { country: 'USA', rate: 78, gender: 'Male' },
-          { country: 'USA', rate: 82, gender: 'Female' },
-          { country: 'Japan', rate: 85, gender: 'Male' },
-          { country: 'Japan', rate: 90, gender: 'Female' },
-          { country: 'Brazil', rate: 60, gender: 'Male' },
-          { country: 'Brazil', rate: 65, gender: 'Female' },
-        ],
-        encoding: {
-          x: { field: 'rate', type: 'quantitative' },
-          y: { field: 'country', type: 'nominal' },
-          color: { field: 'gender', type: 'nominal' },
-        },
-        chrome: {},
-        annotations: [],
-        responsive: true,
-        theme: {},
-        darkMode: 'off',
-        labels: { density: 'auto', format: '' },
-      };
-    }
-
-    it('renders connecting bars and dots for multi-series', () => {
-      const spec = makeDumbbellSpec();
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-
-      const points = marks.filter((m): m is PointMark => m.type === 'point');
-      const bars = marks.filter((m): m is RectMark => m.type === 'rect');
-
-      // 6 data rows = 6 dots
-      expect(points).toHaveLength(6);
-      // 3 categories = 3 connecting bars
-      expect(bars).toHaveLength(3);
-    });
-
-    it('connecting bars span from min to max value per category', () => {
-      const spec = makeDumbbellSpec();
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-
-      const bars = marks.filter((m): m is RectMark => m.type === 'rect');
-      for (const bar of bars) {
-        expect(bar.width).toBeGreaterThan(0);
-      }
-    });
-
-    it('connecting bars use stem color (gray)', () => {
-      const spec = makeDumbbellSpec();
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-
-      const bars = marks.filter((m): m is RectMark => m.type === 'rect');
-      for (const bar of bars) {
-        expect(bar.fill).toBe('#cccccc');
-      }
-    });
-
-    it('dots within same category share the same cy position', () => {
-      const spec = makeDumbbellSpec();
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-
-      const points = marks.filter((m): m is PointMark => m.type === 'point');
-      const usaDots = points.filter((m) => m.aria.label.includes('USA'));
-      expect(usaDots).toHaveLength(2);
-      expect(usaDots[0].cy).toBe(usaDots[1].cy);
-    });
-
-    it('dots for different series have different fill colors', () => {
-      const spec = makeDumbbellSpec();
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-
-      const points = marks.filter((m): m is PointMark => m.type === 'point');
-      const maleDot = points.find((m) => m.aria.label.includes('Male'))!;
-      const femaleDot = points.find((m) => m.aria.label.includes('Female'))!;
-      expect(maleDot.fill).not.toBe(femaleDot.fill);
-    });
-
-    it('connecting bars render before dots (lower z-index)', () => {
-      const spec = makeDumbbellSpec();
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-
-      // First mark should be a rect (connecting bar renders before dots)
-      expect(marks[0].type).toBe('rect');
-    });
-
-    it('aria labels include category and series name', () => {
-      const spec = makeDumbbellSpec();
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-
-      const points = marks.filter((m): m is PointMark => m.type === 'point');
-      const usaMale = points.find(
-        (m) => m.aria.label.includes('USA') && m.aria.label.includes('Male'),
-      );
-      expect(usaMale).toBeDefined();
-      expect(usaMale!.aria.label).toContain('78');
-    });
-  });
-
-  describe('negative values', () => {
-    it('handles negative values (stem extends left of baseline)', () => {
-      const spec = makeColoredDotSpec();
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-
-      const points = marks.filter((m): m is PointMark => m.type === 'point');
-      const debtDot = points.find((m) => m.data.item === 'Debt')!;
-      const revenueDot = points.find((m) => m.data.item === 'Revenue')!;
-
-      // Debt (-10) should be to the left of Revenue (120)
-      expect(debtDot.cx).toBeLessThan(revenueDot.cx);
-    });
-  });
-
-  describe('baseline clamping', () => {
-    it('clamps stems to the plot area when domain does not include zero', () => {
-      const spec: NormalizedChartSpec = {
-        markType: 'circle',
-        markDef: { type: 'circle' },
-        data: [
-          { country: 'USA', score: 50 },
-          { country: 'UK', score: 80 },
-        ],
-        encoding: {
-          x: { field: 'score', type: 'quantitative', scale: { domain: [40, 100] } },
-          y: { field: 'country', type: 'nominal' },
-        },
-        chrome: {},
-        annotations: [],
-        responsive: true,
-        theme: {},
-        darkMode: 'off',
-        labels: { density: 'auto', format: '' },
-      };
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-
-      const stems = marks.filter((m): m is RectMark => m.type === 'rect');
-      for (const stem of stems) {
-        expect(stem.x).toBeGreaterThanOrEqual(chartArea.x);
-        expect(stem.x + stem.width).toBeLessThanOrEqual(chartArea.x + chartArea.width);
-      }
-    });
-  });
-
-  describe('edge cases', () => {
-    it('returns empty array when no x encoding', () => {
-      const spec: NormalizedChartSpec = {
-        markType: 'circle',
-        markDef: { type: 'circle' },
-        data: [{ country: 'USA', score: 85 }],
-        encoding: {
-          y: { field: 'country', type: 'nominal' },
-        },
-        chrome: {},
-        annotations: [],
-        responsive: true,
-        theme: {},
-        darkMode: 'off',
-        labels: { density: 'auto', format: '' },
-      };
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-      expect(marks).toHaveLength(0);
-    });
-
-    it('returns empty array for empty data', () => {
-      const spec: NormalizedChartSpec = {
-        markType: 'circle',
-        markDef: { type: 'circle' },
-        data: [],
-        encoding: {
-          x: { field: 'score', type: 'quantitative' },
-          y: { field: 'country', type: 'nominal' },
-        },
-        chrome: {},
-        annotations: [],
-        responsive: true,
-        theme: {},
-        darkMode: 'off',
-        labels: { density: 'auto', format: '' },
-      };
-      const scales = computeScales(spec, chartArea, spec.data);
-      const marks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-      expect(marks).toHaveLength(0);
-    });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// computeDotLabels tests
-// ---------------------------------------------------------------------------
-
-describe('computeDotLabels', () => {
-  it('produces labels for each dot mark', () => {
-    const spec = makeSimpleDotSpec();
-    const scales = computeScales(spec, chartArea, spec.data);
-    const allMarks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-    const points = allMarks.filter((m): m is PointMark => m.type === 'point');
-    const labels = computeDotLabels(points, chartArea);
-
-    expect(labels).toHaveLength(points.length);
-  });
-
-  it('labels are positioned to the right of dots', () => {
-    const spec = makeSimpleDotSpec();
-    const scales = computeScales(spec, chartArea, spec.data);
-    const allMarks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-    const points = allMarks.filter((m): m is PointMark => m.type === 'point');
-    const labels = computeDotLabels(points, chartArea);
-
-    for (let i = 0; i < labels.length; i++) {
-      expect(labels[i].x).toBeGreaterThan(points[i].cx);
-    }
-  });
-
-  it('labels contain the numeric values', () => {
-    const spec = makeSimpleDotSpec();
-    const scales = computeScales(spec, chartArea, spec.data);
-    const allMarks = computeDotMarks(spec, scales, chartArea, fullStrategy);
-    const points = allMarks.filter((m): m is PointMark => m.type === 'point');
-    const labels = computeDotLabels(points, chartArea);
-
-    const texts = labels.map((l) => l.text);
-    expect(texts).toContain('85');
-    expect(texts).toContain('90');
-  });
-});