@opendata-ai/openchart-engine 8.0.0-rc.9 → 8.1.0

package/src/tables/__tests__/sort.test.ts

@@ -1,107 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { sortData } from '../sort';
-
-describe('sortData', () => {
-  it('sorts numbers numerically ascending', () => {
-    const data = [
-      { name: 'C', value: 30 },
-      { name: 'A', value: 10 },
-      { name: 'B', value: 20 },
-    ];
-    const result = sortData(data, { column: 'value', direction: 'asc' });
-    expect(result.data.map((r) => r.value)).toEqual([10, 20, 30]);
-  });
-
-  it('sorts numbers numerically descending', () => {
-    const data = [
-      { name: 'A', value: 10 },
-      { name: 'C', value: 30 },
-      { name: 'B', value: 20 },
-    ];
-    const result = sortData(data, { column: 'value', direction: 'desc' });
-    expect(result.data.map((r) => r.value)).toEqual([30, 20, 10]);
-  });
-
-  it('sorts strings via localeCompare', () => {
-    const data = [
-      { name: 'Charlie', value: 1 },
-      { name: 'Alice', value: 2 },
-      { name: 'Bob', value: 3 },
-    ];
-    const result = sortData(data, { column: 'name', direction: 'asc' });
-    expect(result.data.map((r) => r.name)).toEqual(['Alice', 'Bob', 'Charlie']);
-  });
-
-  it('sorts dates by timestamp', () => {
-    const d1 = new Date('2020-01-01');
-    const d2 = new Date('2021-06-15');
-    const d3 = new Date('2019-12-31');
-    const data = [
-      { date: d1, val: 1 },
-      { date: d2, val: 2 },
-      { date: d3, val: 3 },
-    ];
-    const result = sortData(data, { column: 'date', direction: 'asc' });
-    expect(result.data.map((r) => r.val)).toEqual([3, 1, 2]);
-  });
-
-  it('puts null values last regardless of sort direction', () => {
-    const data = [
-      { name: 'A', value: null },
-      { name: 'B', value: 20 },
-      { name: 'C', value: 10 },
-    ];
-
-    const asc = sortData(data, { column: 'value', direction: 'asc' });
-    expect(asc.data.map((r) => r.name)).toEqual(['C', 'B', 'A']);
-
-    const desc = sortData(data, { column: 'value', direction: 'desc' });
-    expect(desc.data.map((r) => r.name)).toEqual(['B', 'C', 'A']);
-  });
-
-  it('is stable (preserves order for equal values)', () => {
-    const data = [
-      { name: 'First', value: 10 },
-      { name: 'Second', value: 10 },
-      { name: 'Third', value: 10 },
-    ];
-    const result = sortData(data, { column: 'value', direction: 'asc' });
-    expect(result.data.map((r) => r.name)).toEqual(['First', 'Second', 'Third']);
-  });
-
-  it('does not mutate the original array', () => {
-    const data = [{ value: 30 }, { value: 10 }, { value: 20 }];
-    const original = [...data];
-    sortData(data, { column: 'value', direction: 'asc' });
-    expect(data).toEqual(original);
-  });
-
-  it('handles single element array', () => {
-    const data = [{ value: 42 }];
-    const result = sortData(data, { column: 'value', direction: 'asc' });
-    expect(result.data).toHaveLength(1);
-    expect(result.data[0].value).toBe(42);
-  });
-
-  it('handles all null values', () => {
-    const data = [
-      { name: 'A', value: null },
-      { name: 'B', value: null },
-    ];
-    const result = sortData(data, { column: 'value', direction: 'asc' });
-    // Stable sort: original order preserved
-    expect(result.data.map((r) => r.name)).toEqual(['A', 'B']);
-  });
-
-  it('returns correct originalIndices for sorted data', () => {
-    const data = [
-      { name: 'C', value: 30 },
-      { name: 'A', value: 10 },
-      { name: 'B', value: 20 },
-    ];
-    const result = sortData(data, { column: 'value', direction: 'asc' });
-    // A (index 1) < B (index 2) < C (index 0)
-    expect(result.originalIndices).toEqual([1, 2, 0]);
-    expect(result.data.map((r) => r.name)).toEqual(['A', 'B', 'C']);
-  });
-});

package/src/tables/__tests__/sparkline.test.ts

@@ -1,122 +0,0 @@
-import type { SparklineColumnConfig } from '@opendata-ai/openchart-core';
-import { resolveTheme } from '@opendata-ai/openchart-core';
-import { describe, expect, it } from 'vitest';
-import { computeSparkline, computeSparklineForRow } from '../sparkline';
-
-const theme = resolveTheme();
-
-describe('computeSparkline', () => {
-  it('normalizes line points to 0-1 range', () => {
-    const config: SparklineColumnConfig = { type: 'line' };
-    const result = computeSparkline([10, 20, 30, 40, 50], config, theme, false);
-
-    expect(result).not.toBeNull();
-    expect(result!.type).toBe('line');
-    expect(result!.points).toHaveLength(5);
-
-    // First point at min should be y=0, last at max should be y=1
-    expect(result!.points[0].y).toBeCloseTo(0);
-    expect(result!.points[4].y).toBeCloseTo(1);
-
-    // X values evenly distributed
-    expect(result!.points[0].x).toBeCloseTo(0);
-    expect(result!.points[4].x).toBeCloseTo(1);
-  });
-
-  it('produces bar data for bar type', () => {
-    const config: SparklineColumnConfig = { type: 'bar' };
-    const result = computeSparkline([0, 50, 100], config, theme, false);
-
-    expect(result).not.toBeNull();
-    expect(result!.type).toBe('bar');
-    expect(result!.bars).toHaveLength(3);
-
-    // Normalized: 0->0, 50->0.5, 100->1
-    expect(result!.bars[0]).toBeCloseTo(0);
-    expect(result!.bars[1]).toBeCloseTo(0.5);
-    expect(result!.bars[2]).toBeCloseTo(1);
-  });
-
-  it('produces column data for column type', () => {
-    const config: SparklineColumnConfig = { type: 'column' };
-    const result = computeSparkline([10, 20, 30], config, theme, false);
-
-    expect(result).not.toBeNull();
-    expect(result!.type).toBe('column');
-    expect(result!.bars).toHaveLength(3);
-  });
-
-  it('returns null for empty values', () => {
-    const config: SparklineColumnConfig = { type: 'line' };
-    const result = computeSparkline([], config, theme, false);
-    expect(result).toBeNull();
-  });
-
-  it('handles all equal values (flat line)', () => {
-    const config: SparklineColumnConfig = { type: 'line' };
-    const result = computeSparkline([5, 5, 5], config, theme, false);
-
-    expect(result).not.toBeNull();
-    // When range is 0, all y values should be 0.5
-    expect(result!.points[0].y).toBeCloseTo(0.5);
-    expect(result!.points[1].y).toBeCloseTo(0.5);
-  });
-
-  it('handles single value', () => {
-    const config: SparklineColumnConfig = { type: 'line' };
-    const result = computeSparkline([42], config, theme, false);
-
-    expect(result).not.toBeNull();
-    expect(result!.points).toHaveLength(1);
-    expect(result!.points[0].x).toBeCloseTo(0.5);
-    expect(result!.points[0].y).toBeCloseTo(0.5);
-  });
-
-  it('uses custom color from config', () => {
-    const config: SparklineColumnConfig = { type: 'line', color: '#ff0000' };
-    const result = computeSparkline([1, 2, 3], config, theme, false);
-    expect(result!.color).toBe('#ff0000');
-  });
-
-  it('defaults to first categorical palette color', () => {
-    const config: SparklineColumnConfig = { type: 'line' };
-    const result = computeSparkline([1, 2, 3], config, theme, false);
-    expect(result!.color).toBe(theme.colors.categorical[0]);
-  });
-});
-
-describe('computeSparklineForRow', () => {
-  it('extracts values from array field', () => {
-    const row = { trend: [10, 20, 30] };
-    const config: SparklineColumnConfig = { type: 'line' };
-    const result = computeSparklineForRow(row, 'trend', config, theme, false);
-
-    expect(result).not.toBeNull();
-    expect(result!.count).toBe(3);
-  });
-
-  it('uses valuesField to extract from different field', () => {
-    const row = { label: 'Test', data: [5, 15, 25] };
-    const config: SparklineColumnConfig = { type: 'line', valuesField: 'data' };
-    const result = computeSparklineForRow(row, 'label', config, theme, false);
-
-    expect(result).not.toBeNull();
-    expect(result!.count).toBe(3);
-  });
-
-  it('returns null when field value is not an array', () => {
-    const row = { trend: 'not an array' };
-    const config: SparklineColumnConfig = { type: 'line' };
-    const result = computeSparklineForRow(row, 'trend', config, theme, false);
-    expect(result).toBeNull();
-  });
-
-  it('filters out non-numeric values from array', () => {
-    const row = { trend: [10, 'bad', null, 30] };
-    const config: SparklineColumnConfig = { type: 'line' };
-    const result = computeSparklineForRow(row, 'trend', config, theme, false);
-
-    expect(result).not.toBeNull();
-    expect(result!.count).toBe(2); // only 10 and 30
-  });
-});

package/src/tables/bar-column.ts

@@ -1,94 +0,0 @@
-/**
- * Bar column computation for inline bar visualization in table cells.
- *
- * Computes bar width as a proportion of the max value.
- * Supports negative values with bidirectional bars.
- */
-
-import type { BarColumnConfig, ResolvedTheme } from '@opendata-ai/openchart-core';
-
-const NEGATIVE_BAR_COLOR = '#c44e52';
-
-/**
- * Compute the bar percentage, offset, and color for a single cell value.
- *
- * barPercent is 0-1. barOffset is 0-1 (left edge position).
- * When the column has negative values, bars extend bidirectionally from a zero line.
- */
-export function computeBarCell(
-  value: number,
-  config: BarColumnConfig,
-  columnMax: number,
-  columnMin: number,
-  theme: ResolvedTheme,
-  _darkMode: boolean,
-): { barPercent: number; barOffset: number; barColor: string; isNegative: boolean } {
-  const barColor = config.color ?? theme.colors.categorical[0];
-  const hasNegatives = columnMin < 0;
-
-  if (!Number.isFinite(value)) {
-    return { barPercent: 0, barOffset: 0, barColor, isNegative: false };
-  }
-
-  if (!hasNegatives) {
-    // Positive-only column: simple left-to-right bars
-    const maxValue = config.maxValue ?? columnMax;
-    if (maxValue <= 0) {
-      return { barPercent: 0, barOffset: 0, barColor, isNegative: false };
-    }
-    const barPercent = Math.max(0, Math.min(1, value / maxValue));
-    return { barPercent, barOffset: 0, barColor, isNegative: false };
-  }
-
-  // Bidirectional: zero line position proportional to data range
-  const maxPos = config.maxValue ?? columnMax;
-  const absMin = Math.abs(columnMin);
-  const totalRange = maxPos + absMin;
-  if (totalRange === 0) {
-    return { barPercent: 0, barOffset: 0, barColor, isNegative: false };
-  }
-
-  const zeroPos = absMin / totalRange;
-
-  if (value >= 0) {
-    const barPercent = value / totalRange;
-    return { barPercent, barOffset: zeroPos, barColor, isNegative: false };
-  }
-
-  // Negative value: red bar extending left from zero
-  const barPercent = Math.abs(value) / totalRange;
-  return {
-    barPercent,
-    barOffset: zeroPos - barPercent,
-    barColor: config.color ?? NEGATIVE_BAR_COLOR,
-    isNegative: true,
-  };
-}
-
-/**
- * Compute the column max and min from data for bar scaling.
- */
-export function computeColumnMax(data: Record<string, unknown>[], key: string): number {
-  let max = 0;
-  for (const row of data) {
-    const val = row[key];
-    if (typeof val === 'number' && Number.isFinite(val) && val > max) {
-      max = val;
-    }
-  }
-  return max;
-}
-
-/**
- * Compute the column minimum from data (for negative bar support).
- */
-export function computeColumnMin(data: Record<string, unknown>[], key: string): number {
-  let min = 0;
-  for (const row of data) {
-    const val = row[key];
-    if (typeof val === 'number' && Number.isFinite(val) && val < min) {
-      min = val;
-    }
-  }
-  return min;
-}

package/src/tables/category-colors.ts

@@ -1,78 +0,0 @@
-/**
- * Category color assignment for table columns.
- *
- * Maps categorical values to colors using explicit mappings or
- * theme categorical palette, with AA-contrast text colors.
- */
-
-import type { CellStyle, ColumnConfig, ResolvedTheme } from '@opendata-ai/openchart-core';
-import { adaptColorForDarkMode } from '@opendata-ai/openchart-core';
-import { accessibleTextColor } from './utils';
-
-/**
- * Compute category-colored cell styles for a column.
- *
- * Uses column.categoryColors for explicit value-to-color mappings.
- * Unmapped values get colors from the theme's categorical palette.
- *
- * Returns a Map keyed by original data index with background and text colors.
- */
-export function computeCategoryColors(
-  data: Record<string, unknown>[],
-  column: ColumnConfig,
-  theme: ResolvedTheme,
-  darkMode: boolean,
-): Map<number, CellStyle> {
-  const result = new Map<number, CellStyle>();
-  const explicitMap = column.categoryColors;
-  if (!explicitMap) return result;
-
-  const categoricalPalette = theme.colors.categorical;
-  let nextPaletteIndex = 0;
-  const autoAssigned = new Map<string, string>();
-  const lightBg = '#ffffff';
-  const darkBg = theme.colors.background;
-
-  for (let i = 0; i < data.length; i++) {
-    const raw = data[i][column.key];
-    if (raw == null) continue;
-
-    const key = String(raw);
-    let bg: string;
-    let isExplicit = false;
-
-    if (explicitMap[key] != null) {
-      if (explicitMap[key] === 'transparent' || explicitMap[key] === 'none') {
-        // Skip transparent/none — let the cell inherit default table styling
-        continue;
-      }
-      bg = explicitMap[key];
-      isExplicit = true;
-    } else if (column.autoAssign) {
-      // Auto-assign from palette only when explicitly opted in
-      if (autoAssigned.has(key)) {
-        bg = autoAssigned.get(key)!;
-      } else {
-        bg = categoricalPalette[nextPaletteIndex % categoricalPalette.length];
-        nextPaletteIndex++;
-        autoAssigned.set(key, bg);
-      }
-    } else {
-      // Default: skip unmapped values (no color assigned)
-      continue;
-    }
-
-    // Dark mode adaptation (skip for explicit user-provided colors)
-    if (darkMode && !isExplicit) {
-      bg = adaptColorForDarkMode(bg, lightBg, darkBg);
-    }
-
-    const textColor = accessibleTextColor(bg);
-    result.set(i, {
-      backgroundColor: bg,
-      color: textColor,
-    });
-  }
-
-  return result;
-}