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

package/src/charts/__tests__/registry.test.ts

@@ -1,116 +0,0 @@
-import type { LayoutStrategy, Mark, Rect } from '@opendata-ai/openchart-core';
-import { afterEach, describe, expect, it } from 'vitest';
-import type { NormalizedChartSpec } from '../../compiler/types';
-import type { ResolvedScales } from '../../layout/scales';
-import { registerBuiltinRenderers } from '../builtin';
-import { clearRenderers, getChartRenderer, registerChartRenderer } from '../registry';
-
-// ---------------------------------------------------------------------------
-// Fixtures
-// ---------------------------------------------------------------------------
-
-/**
- * A minimal renderer that returns a single rect mark.
- * Used to verify the registry lifecycle without needing real chart logic.
- */
-function stubRenderer(
-  _spec: NormalizedChartSpec,
-  _scales: ResolvedScales,
-  _chartArea: Rect,
-  _strategy: LayoutStrategy,
-): Mark[] {
-  return [
-    {
-      type: 'rect',
-      x: 10,
-      y: 20,
-      width: 100,
-      height: 50,
-      fill: '#ff0000',
-      data: {},
-      aria: { label: 'stub mark' },
-    },
-  ];
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('chart renderer registry', () => {
-  afterEach(() => {
-    // Clear test-registered renderers AND restore the built-in set. The
-    // built-ins register as a module side-effect of importing `compile.ts`,
-    // so once cleared they don't come back on their own — leaving later
-    // tests in this suite with an empty registry.
-    clearRenderers();
-    registerBuiltinRenderers();
-  });
-
-  it('returns undefined for an unregistered chart type', () => {
-    expect(getChartRenderer('nonexistent')).toBeUndefined();
-  });
-
-  it('registers and retrieves a renderer by type', () => {
-    registerChartRenderer('test-type', stubRenderer);
-
-    const retrieved = getChartRenderer('test-type');
-    expect(retrieved).toBe(stubRenderer);
-  });
-
-  it('registered renderer produces marks when called', () => {
-    registerChartRenderer('test-type', stubRenderer);
-
-    const renderer = getChartRenderer('test-type')!;
-    const marks = renderer(
-      {} as NormalizedChartSpec,
-      {} as ResolvedScales,
-      { x: 0, y: 0, width: 600, height: 400 },
-      {} as LayoutStrategy,
-    );
-
-    expect(marks).toHaveLength(1);
-    expect(marks[0].type).toBe('rect');
-    if (marks[0].type === 'rect') {
-      expect(marks[0].width).toBe(100);
-      expect(marks[0].fill).toBe('#ff0000');
-    }
-  });
-
-  it('overwrites a previously registered renderer for the same type', () => {
-    const secondRenderer = () => [] as Mark[];
-
-    registerChartRenderer('test-type', stubRenderer);
-    registerChartRenderer('test-type', secondRenderer);
-
-    expect(getChartRenderer('test-type')).toBe(secondRenderer);
-  });
-
-  it('clearRenderers removes all registered renderers', () => {
-    registerChartRenderer('type-a', stubRenderer);
-    registerChartRenderer('type-b', stubRenderer);
-
-    // Both should be registered
-    expect(getChartRenderer('type-a')).toBe(stubRenderer);
-    expect(getChartRenderer('type-b')).toBe(stubRenderer);
-
-    clearRenderers();
-
-    // Both should be gone
-    expect(getChartRenderer('type-a')).toBeUndefined();
-    expect(getChartRenderer('type-b')).toBeUndefined();
-  });
-
-  it('multiple types can be registered independently', () => {
-    const rendererA = () => [] as Mark[];
-    const rendererB = () => [] as Mark[];
-
-    registerChartRenderer('type-a', rendererA);
-    registerChartRenderer('type-b', rendererB);
-
-    expect(getChartRenderer('type-a')).toBe(rendererA);
-    expect(getChartRenderer('type-b')).toBe(rendererB);
-    // Unregistered type still returns undefined
-    expect(getChartRenderer('type-c')).toBeUndefined();
-  });
-});

package/src/charts/__tests__/utils.test.ts

@@ -1,195 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { sortByField } from '../utils';
-
-describe('sortByField', () => {
-  // -----------------------------------------------------------------------
-  // Numeric sorting
-  // -----------------------------------------------------------------------
-
-  it('sorts numeric values ascending', () => {
-    const data = [{ v: 30 }, { v: 10 }, { v: 20 }];
-    const sorted = sortByField(data, 'v');
-    expect(sorted.map((r) => r.v)).toEqual([10, 20, 30]);
-  });
-
-  it('sorts negative and positive numbers correctly', () => {
-    const data = [{ v: 5 }, { v: -3 }, { v: 0 }, { v: -1 }, { v: 2 }];
-    const sorted = sortByField(data, 'v');
-    expect(sorted.map((r) => r.v)).toEqual([-3, -1, 0, 2, 5]);
-  });
-
-  it('sorts floating point numbers correctly', () => {
-    const data = [{ v: 1.5 }, { v: 1.1 }, { v: 1.9 }, { v: 1.3 }];
-    const sorted = sortByField(data, 'v');
-    expect(sorted.map((r) => r.v)).toEqual([1.1, 1.3, 1.5, 1.9]);
-  });
-
-  // -----------------------------------------------------------------------
-  // Date string sorting (ISO format)
-  // -----------------------------------------------------------------------
-
-  it('sorts ISO date strings (YYYY-MM-DD) lexicographically', () => {
-    const data = [
-      { date: '2022-01-01', v: 1 },
-      { date: '2020-06-15', v: 2 },
-      { date: '2021-03-10', v: 3 },
-    ];
-    const sorted = sortByField(data, 'date');
-    expect(sorted.map((r) => r.date)).toEqual(['2020-06-15', '2021-03-10', '2022-01-01']);
-  });
-
-  it('sorts dates within the same year by month and day', () => {
-    const data = [
-      { date: '2020-12-25' },
-      { date: '2020-01-01' },
-      { date: '2020-06-15' },
-      { date: '2020-03-20' },
-    ];
-    const sorted = sortByField(data, 'date');
-    expect(sorted.map((r) => r.date)).toEqual([
-      '2020-01-01',
-      '2020-03-20',
-      '2020-06-15',
-      '2020-12-25',
-    ]);
-  });
-
-  it('sorts full ISO datetime strings with time component', () => {
-    const data = [
-      { ts: '2020-01-01T23:59:59Z' },
-      { ts: '2020-01-01T00:00:00Z' },
-      { ts: '2020-01-01T12:30:00Z' },
-    ];
-    const sorted = sortByField(data, 'ts');
-    expect(sorted.map((r) => r.ts)).toEqual([
-      '2020-01-01T00:00:00Z',
-      '2020-01-01T12:30:00Z',
-      '2020-01-01T23:59:59Z',
-    ]);
-  });
-
-  it('sorts reverse-ordered dates correctly', () => {
-    const data = [
-      { date: '2025-01-01' },
-      { date: '2024-01-01' },
-      { date: '2023-01-01' },
-      { date: '2022-01-01' },
-    ];
-    const sorted = sortByField(data, 'date');
-    expect(sorted.map((r) => r.date)).toEqual([
-      '2022-01-01',
-      '2023-01-01',
-      '2024-01-01',
-      '2025-01-01',
-    ]);
-  });
-
-  // -----------------------------------------------------------------------
-  // String-encoded numbers (year columns from CSV data)
-  // -----------------------------------------------------------------------
-
-  it('sorts string-encoded year numbers numerically', () => {
-    const data = [{ year: '2022' }, { year: '2020' }, { year: '2021' }];
-    const sorted = sortByField(data, 'year');
-    expect(sorted.map((r) => r.year)).toEqual(['2020', '2021', '2022']);
-  });
-
-  it('sorts string-encoded decimal numbers numerically', () => {
-    const data = [{ v: '10.5' }, { v: '2.3' }, { v: '100.1' }];
-    const sorted = sortByField(data, 'v');
-    expect(sorted.map((r) => r.v)).toEqual(['2.3', '10.5', '100.1']);
-  });
-
-  // -----------------------------------------------------------------------
-  // Date objects
-  // -----------------------------------------------------------------------
-
-  it('sorts Date objects by timestamp', () => {
-    const d1 = new Date('2020-06-15T00:00:00');
-    const d2 = new Date('2021-06-15T00:00:00');
-    const d3 = new Date('2022-06-15T00:00:00');
-    const data = [{ d: d3 }, { d: d1 }, { d: d2 }];
-    const sorted = sortByField(data, 'd');
-    expect(sorted.map((r) => r.d)).toEqual([d1, d2, d3]);
-  });
-
-  // -----------------------------------------------------------------------
-  // Null / undefined handling
-  // -----------------------------------------------------------------------
-
-  it('pushes nulls to the end', () => {
-    const data = [{ v: null }, { v: 10 }, { v: 30 }, { v: null }, { v: 20 }];
-    const sorted = sortByField(data, 'v');
-    expect(sorted.map((r) => r.v)).toEqual([10, 20, 30, null, null]);
-  });
-
-  it('pushes undefined (missing field) to the end', () => {
-    const data = [{ other: 1 }, { v: 10, other: 2 }, { v: 20, other: 3 }];
-    const sorted = sortByField(data, 'v');
-    expect(sorted.map((r) => r.v)).toEqual([10, 20, undefined]);
-  });
-
-  it('handles all-null values without crashing', () => {
-    const data = [{ v: null }, { v: null }, { v: null }];
-    const sorted = sortByField(data, 'v');
-    expect(sorted).toHaveLength(3);
-    expect(sorted.every((r) => r.v === null)).toBe(true);
-  });
-
-  // -----------------------------------------------------------------------
-  // Duplicate values
-  // -----------------------------------------------------------------------
-
-  it('handles duplicate values preserving both rows', () => {
-    const data = [{ v: 20 }, { v: 10 }, { v: 20 }, { v: 10 }];
-    const sorted = sortByField(data, 'v');
-    expect(sorted.map((r) => r.v)).toEqual([10, 10, 20, 20]);
-  });
-
-  it('handles duplicate date strings', () => {
-    const data = [
-      { date: '2021-01-01', id: 'c' },
-      { date: '2020-01-01', id: 'b' },
-      { date: '2021-01-01', id: 'a' },
-    ];
-    const sorted = sortByField(data, 'date');
-    // Both 2021 rows follow the 2020 row
-    expect(sorted[0].date).toBe('2020-01-01');
-    expect(sorted[1].date).toBe('2021-01-01');
-    expect(sorted[2].date).toBe('2021-01-01');
-  });
-
-  // -----------------------------------------------------------------------
-  // Edge cases
-  // -----------------------------------------------------------------------
-
-  it('returns a new array (no mutation)', () => {
-    const data = [{ v: 30 }, { v: 10 }];
-    const sorted = sortByField(data, 'v');
-    expect(sorted).not.toBe(data);
-    expect(data[0].v).toBe(30);
-  });
-
-  it('handles empty array', () => {
-    expect(sortByField([], 'v')).toEqual([]);
-  });
-
-  it('handles single element', () => {
-    const data = [{ v: 42 }];
-    const sorted = sortByField(data, 'v');
-    expect(sorted).toHaveLength(1);
-    expect(sorted[0].v).toBe(42);
-  });
-
-  it('handles already-sorted data', () => {
-    const data = [{ v: 1 }, { v: 2 }, { v: 3 }];
-    const sorted = sortByField(data, 'v');
-    expect(sorted.map((r) => r.v)).toEqual([1, 2, 3]);
-  });
-
-  it('sorts pure string values lexicographically', () => {
-    const data = [{ name: 'cherry' }, { name: 'apple' }, { name: 'banana' }];
-    const sorted = sortByField(data, 'name');
-    expect(sorted.map((r) => r.name)).toEqual(['apple', 'banana', 'cherry']);
-  });
-});

package/src/charts/_shared/__tests__/density-filter.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { filterByDensity } from '../density-filter';
-
-describe('filterByDensity', () => {
-  const marks = ['a', 'b', 'c', 'd'];
-
-  it("returns [] for 'none'", () => {
-    expect(filterByDensity(marks, 'none')).toEqual([]);
-  });
-
-  it("returns first + last for 'endpoints'", () => {
-    expect(filterByDensity(marks, 'endpoints')).toEqual(['a', 'd']);
-  });
-
-  it("returns marks unchanged for 'all'", () => {
-    expect(filterByDensity(marks, 'all')).toBe(marks);
-  });
-
-  it("returns marks unchanged for 'auto'", () => {
-    expect(filterByDensity(marks, 'auto')).toBe(marks);
-  });
-
-  it("returns single-element array unchanged for 'endpoints'", () => {
-    const single = ['only'];
-    expect(filterByDensity(single, 'endpoints')).toBe(single);
-  });
-
-  it("returns empty array unchanged for 'endpoints'", () => {
-    const empty: string[] = [];
-    expect(filterByDensity(empty, 'endpoints')).toBe(empty);
-  });
-});

package/src/charts/_shared/density-filter.ts

@@ -1,26 +0,0 @@
-/**
- * Shared density filter for data labels.
- *
- * Maps a `LabelDensity` setting to the subset of marks eligible for
- * labeling. The `'auto'` branch is a pass-through — auto resolution
- * happens upstream in the per-chart label modules (typically via
- * collision detection on the full candidate set).
- */
-
-import type { LabelDensity } from '@opendata-ai/openchart-core';
-
-/**
- * Filter a mark array by label density.
- *
- * - `'none'` returns `[]` (no labels)
- * - `'endpoints'` returns first + last marks when `marks.length > 1`,
- *   otherwise the input unchanged (preserves single-element arrays as-is)
- * - `'all'` and `'auto'` return the input unchanged
- */
-export function filterByDensity<T>(marks: T[], density: LabelDensity): T[] {
-  if (density === 'none') return [];
-  if (density === 'endpoints' && marks.length > 1) {
-    return [marks[0], marks[marks.length - 1]];
-  }
-  return marks;
-}

package/src/charts/_shared/format-label-value.ts

@@ -1,16 +0,0 @@
-/**
- * Shared numeric value formatter for data labels.
- *
- * Used by bar, column, and dot label computation to display a value
- * with smart compact defaults (k/M/B/T).
- */
-
-import type { FieldFormatContext } from '@opendata-ai/openchart-core';
-import { defaultNumberFormatter } from '@opendata-ai/openchart-core';
-
-const defaultFmt = defaultNumberFormatter();
-
-/** Format a label value for display (compact by default). */
-export function formatLabelValue(value: number, ctx?: FieldFormatContext): string {
-  return (ctx ? defaultNumberFormatter(ctx) : defaultFmt)(value);
-}