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

package/src/transforms/__tests__/aggregate.test.ts

@@ -1,159 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { runAggregate } from '../aggregate';
-
-describe('runAggregate', () => {
-  const data = [
-    { region: 'North', product: 'A', revenue: 100, qty: 10 },
-    { region: 'North', product: 'B', revenue: 200, qty: 20 },
-    { region: 'South', product: 'A', revenue: 150, qty: 15 },
-    { region: 'South', product: 'B', revenue: 250, qty: 25 },
-    { region: 'South', product: 'A', revenue: 50, qty: 5 },
-  ];
-
-  it('computes sum aggregate grouped by one field', () => {
-    const result = runAggregate(data, {
-      aggregate: [{ op: 'sum', field: 'revenue', as: 'total_revenue' }],
-      groupby: ['region'],
-    });
-
-    expect(result).toHaveLength(2);
-    const north = result.find((r) => r.region === 'North');
-    const south = result.find((r) => r.region === 'South');
-    expect(north?.total_revenue).toBe(300);
-    expect(south?.total_revenue).toBe(450);
-  });
-
-  it('computes mean aggregate', () => {
-    const result = runAggregate(data, {
-      aggregate: [{ op: 'mean', field: 'revenue', as: 'avg_revenue' }],
-      groupby: ['region'],
-    });
-
-    const north = result.find((r) => r.region === 'North');
-    const south = result.find((r) => r.region === 'South');
-    expect(north?.avg_revenue).toBe(150); // (100+200)/2
-    expect(south?.avg_revenue).toBe(150); // (150+250+50)/3
-  });
-
-  it('computes count aggregate', () => {
-    const result = runAggregate(data, {
-      aggregate: [{ op: 'count', field: 'revenue', as: 'num_rows' }],
-      groupby: ['region'],
-    });
-
-    const north = result.find((r) => r.region === 'North');
-    const south = result.find((r) => r.region === 'South');
-    expect(north?.num_rows).toBe(2);
-    expect(south?.num_rows).toBe(3);
-  });
-
-  it('computes median aggregate', () => {
-    const result = runAggregate(data, {
-      aggregate: [{ op: 'median', field: 'revenue', as: 'med_revenue' }],
-      groupby: ['region'],
-    });
-
-    const north = result.find((r) => r.region === 'North');
-    const south = result.find((r) => r.region === 'South');
-    expect(north?.med_revenue).toBe(150); // median of [100, 200]
-    expect(south?.med_revenue).toBe(150); // median of [50, 150, 250]
-  });
-
-  it('computes min and max aggregates', () => {
-    const result = runAggregate(data, {
-      aggregate: [
-        { op: 'min', field: 'revenue', as: 'min_rev' },
-        { op: 'max', field: 'revenue', as: 'max_rev' },
-      ],
-      groupby: ['region'],
-    });
-
-    const south = result.find((r) => r.region === 'South');
-    expect(south?.min_rev).toBe(50);
-    expect(south?.max_rev).toBe(250);
-  });
-
-  it('supports multiple groupby fields', () => {
-    const result = runAggregate(data, {
-      aggregate: [{ op: 'sum', field: 'revenue', as: 'total' }],
-      groupby: ['region', 'product'],
-    });
-
-    expect(result).toHaveLength(4);
-    const southA = result.find((r) => r.region === 'South' && r.product === 'A');
-    expect(southA?.total).toBe(200); // 150 + 50
-  });
-
-  it('supports multiple aggregate ops in one transform', () => {
-    const result = runAggregate(data, {
-      aggregate: [
-        { op: 'sum', field: 'revenue', as: 'total_rev' },
-        { op: 'mean', field: 'qty', as: 'avg_qty' },
-      ],
-      groupby: ['region'],
-    });
-
-    const north = result.find((r) => r.region === 'North');
-    expect(north?.total_rev).toBe(300);
-    expect(north?.avg_qty).toBe(15); // (10+20)/2
-  });
-
-  it('computes variance aggregate', () => {
-    const result = runAggregate(data, {
-      aggregate: [{ op: 'variance', field: 'revenue', as: 'var_rev' }],
-      groupby: ['region'],
-    });
-
-    const south = result.find((r) => r.region === 'South');
-    // South values: [150, 250, 50], mean=150, variance = ((0)^2 + (100)^2 + (-100)^2) / 3
-    expect(south?.var_rev).toBeCloseTo(6666.667, 0);
-  });
-
-  it('computes stdev aggregate', () => {
-    const result = runAggregate(data, {
-      aggregate: [{ op: 'stdev', field: 'revenue', as: 'sd_rev' }],
-      groupby: ['region'],
-    });
-
-    const south = result.find((r) => r.region === 'South');
-    // sqrt(6666.667) ≈ 81.65
-    expect(south?.sd_rev).toBeCloseTo(81.65, 1);
-  });
-
-  it('computes distinct aggregate (counts unique raw values)', () => {
-    const result = runAggregate(data, {
-      aggregate: [{ op: 'distinct', field: 'product', as: 'n_products' }],
-      groupby: ['region'],
-    });
-
-    const north = result.find((r) => r.region === 'North');
-    const south = result.find((r) => r.region === 'South');
-    expect(north?.n_products).toBe(2); // A, B
-    expect(south?.n_products).toBe(2); // A, B (A appears twice but distinct=2)
-  });
-
-  it('computes q1 and q3 aggregates', () => {
-    const result = runAggregate(data, {
-      aggregate: [
-        { op: 'q1', field: 'revenue', as: 'q1_rev' },
-        { op: 'q3', field: 'revenue', as: 'q3_rev' },
-      ],
-      groupby: ['region'],
-    });
-
-    const south = result.find((r) => r.region === 'South');
-    // South values sorted: [50, 150, 250]
-    // q1: index = (3-1)*0.25 = 0.5 -> 50 + 0.5*(150-50) = 100
-    // q3: index = (3-1)*0.75 = 1.5 -> 150 + 0.5*(250-150) = 200
-    expect(south?.q1_rev).toBe(100);
-    expect(south?.q3_rev).toBe(200);
-  });
-
-  it('handles empty data', () => {
-    const result = runAggregate([], {
-      aggregate: [{ op: 'sum', field: 'revenue', as: 'total' }],
-      groupby: ['region'],
-    });
-    expect(result).toHaveLength(0);
-  });
-});

package/src/transforms/__tests__/bin.test.ts

@@ -1,88 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { runBin } from '../bin';
-
-describe('runBin', () => {
-  const data = [{ value: 2 }, { value: 7 }, { value: 12 }, { value: 18 }, { value: 23 }];
-
-  it('bins with default params (bin: true)', () => {
-    const result = runBin(data, { bin: true, field: 'value', as: 'binned' });
-    expect(result).toHaveLength(5);
-    // Each row should have a 'binned' field
-    for (const row of result) {
-      expect(row).toHaveProperty('binned');
-    }
-    // Original data should be preserved
-    expect(result[0].value).toBe(2);
-  });
-
-  it('bins with explicit maxbins', () => {
-    const result = runBin(data, {
-      bin: { maxbins: 5 },
-      field: 'value',
-      as: 'binned',
-    });
-    // With 5 bins over range 2-23, step should be roughly 5
-    const binValues = new Set(result.map((r) => r.binned));
-    expect(binValues.size).toBeGreaterThanOrEqual(2);
-    expect(binValues.size).toBeLessThanOrEqual(6);
-  });
-
-  it('bins with explicit step', () => {
-    const result = runBin(data, {
-      bin: { step: 10 },
-      field: 'value',
-      as: 'binned',
-    });
-    // Step=10 from extent [2,23]: bins at 2, 12, 22
-    const binValues = [...new Set(result.map((r) => r.binned))].sort(
-      (a, b) => (a as number) - (b as number),
-    );
-    expect(binValues.length).toBeGreaterThanOrEqual(2);
-  });
-
-  it('produces [start, end] when as is a tuple', () => {
-    const result = runBin(data, {
-      bin: { step: 10 },
-      field: 'value',
-      as: ['bin_start', 'bin_end'],
-    });
-    for (const row of result) {
-      expect(row).toHaveProperty('bin_start');
-      expect(row).toHaveProperty('bin_end');
-      if (row.bin_start !== null) {
-        expect((row.bin_end as number) - (row.bin_start as number)).toBe(10);
-      }
-    }
-  });
-
-  it('bins with explicit extent', () => {
-    const result = runBin(data, {
-      bin: { extent: [0, 30], step: 10 },
-      field: 'value',
-      as: 'binned',
-    });
-    // All values should fall in bins starting at 0, 10, 20
-    const binValues = new Set(result.map((r) => r.binned));
-    for (const v of binValues) {
-      expect([0, 10, 20]).toContain(v);
-    }
-  });
-
-  it('handles NaN values gracefully', () => {
-    const dataWithNaN = [{ value: 5 }, { value: NaN }];
-    const result = runBin(dataWithNaN, { bin: true, field: 'value', as: 'binned' });
-    expect(result[1].binned).toBeNull();
-  });
-
-  it('handles empty data', () => {
-    const result = runBin([], { bin: true, field: 'value', as: 'binned' });
-    expect(result).toHaveLength(0);
-  });
-
-  it('preserves existing fields', () => {
-    const dataWithExtra = [{ value: 5, name: 'test' }];
-    const result = runBin(dataWithExtra, { bin: true, field: 'value', as: 'binned' });
-    expect(result[0].name).toBe('test');
-    expect(result[0].value).toBe(5);
-  });
-});

package/src/transforms/__tests__/calculate.test.ts

@@ -1,146 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { runCalculate } from '../calculate';
-
-describe('runCalculate', () => {
-  const data = [
-    { x: 10, y: 3 },
-    { x: -5, y: 2 },
-    { x: 100, y: 0 },
-  ];
-
-  describe('binary operations with field2', () => {
-    it('adds two fields', () => {
-      const result = runCalculate(data, {
-        calculate: { op: '+', field: 'x', field2: 'y' },
-        as: 'sum',
-      });
-      expect(result[0].sum).toBe(13);
-      expect(result[1].sum).toBe(-3);
-    });
-
-    it('subtracts two fields', () => {
-      const result = runCalculate(data, {
-        calculate: { op: '-', field: 'x', field2: 'y' },
-        as: 'diff',
-      });
-      expect(result[0].diff).toBe(7);
-    });
-
-    it('multiplies two fields', () => {
-      const result = runCalculate(data, {
-        calculate: { op: '*', field: 'x', field2: 'y' },
-        as: 'product',
-      });
-      expect(result[0].product).toBe(30);
-    });
-
-    it('divides two fields', () => {
-      const result = runCalculate(data, {
-        calculate: { op: '/', field: 'x', field2: 'y' },
-        as: 'ratio',
-      });
-      expect(result[0].ratio).toBeCloseTo(10 / 3);
-    });
-  });
-
-  describe('binary operations with value', () => {
-    it('adds a constant', () => {
-      const result = runCalculate(data, {
-        calculate: { op: '+', field: 'x', value: 5 },
-        as: 'result',
-      });
-      expect(result[0].result).toBe(15);
-    });
-
-    it('multiplies by a constant', () => {
-      const result = runCalculate(data, {
-        calculate: { op: '*', field: 'x', value: 2 },
-        as: 'result',
-      });
-      expect(result[0].result).toBe(20);
-    });
-  });
-
-  describe('division by zero', () => {
-    it('returns NaN for division by zero', () => {
-      const result = runCalculate(data, {
-        calculate: { op: '/', field: 'x', field2: 'y' },
-        as: 'ratio',
-      });
-      // Third row: x=100, y=0
-      expect(result[2].ratio).toBeNaN();
-    });
-  });
-
-  describe('unary operations', () => {
-    it('abs', () => {
-      const result = runCalculate(data, {
-        calculate: { op: 'abs', field: 'x' },
-        as: 'result',
-      });
-      expect(result[0].result).toBe(10);
-      expect(result[1].result).toBe(5);
-    });
-
-    it('round', () => {
-      const floatData = [{ v: 3.7 }, { v: 3.2 }];
-      const result = runCalculate(floatData, {
-        calculate: { op: 'round', field: 'v' },
-        as: 'result',
-      });
-      expect(result[0].result).toBe(4);
-      expect(result[1].result).toBe(3);
-    });
-
-    it('floor', () => {
-      const floatData = [{ v: 3.9 }];
-      const result = runCalculate(floatData, {
-        calculate: { op: 'floor', field: 'v' },
-        as: 'result',
-      });
-      expect(result[0].result).toBe(3);
-    });
-
-    it('ceil', () => {
-      const floatData = [{ v: 3.1 }];
-      const result = runCalculate(floatData, {
-        calculate: { op: 'ceil', field: 'v' },
-        as: 'result',
-      });
-      expect(result[0].result).toBe(4);
-    });
-
-    it('log', () => {
-      const result = runCalculate([{ v: Math.E }], {
-        calculate: { op: 'log', field: 'v' },
-        as: 'result',
-      });
-      expect(result[0].result).toBeCloseTo(1);
-    });
-
-    it('sqrt', () => {
-      const result = runCalculate([{ v: 16 }], {
-        calculate: { op: 'sqrt', field: 'v' },
-        as: 'result',
-      });
-      expect(result[0].result).toBe(4);
-    });
-  });
-
-  it('preserves existing fields', () => {
-    const result = runCalculate(data, {
-      calculate: { op: 'abs', field: 'x' },
-      as: 'absX',
-    });
-    expect(result[0].x).toBe(10);
-    expect(result[0].y).toBe(3);
-  });
-
-  it('handles empty data', () => {
-    const result = runCalculate([], {
-      calculate: { op: '+', field: 'x', value: 1 },
-      as: 'result',
-    });
-    expect(result).toHaveLength(0);
-  });
-});

package/src/transforms/__tests__/conditional.test.ts

@@ -1,127 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { isConditionalValueDef, resolveConditionalValue } from '../conditional';
-
-describe('resolveConditionalValue', () => {
-  it('returns condition value when test passes', () => {
-    const result = resolveConditionalValue(
-      { category: 'A', value: 10 },
-      {
-        condition: { test: { field: 'category', equal: 'A' }, value: 'red' },
-        value: 'gray',
-      },
-    );
-    expect(result).toBe('red');
-  });
-
-  it('returns default value when test fails', () => {
-    const result = resolveConditionalValue(
-      { category: 'B', value: 10 },
-      {
-        condition: { test: { field: 'category', equal: 'A' }, value: 'red' },
-        value: 'gray',
-      },
-    );
-    expect(result).toBe('gray');
-  });
-
-  it('evaluates multiple conditions in order', () => {
-    const def = {
-      condition: [
-        { test: { field: 'value', gt: 90 }, value: 'red' },
-        { test: { field: 'value', gt: 50 }, value: 'orange' },
-        { test: { field: 'value', gt: 0 }, value: 'green' },
-      ],
-      value: 'gray',
-    };
-
-    expect(resolveConditionalValue({ value: 95 }, def)).toBe('red');
-    expect(resolveConditionalValue({ value: 70 }, def)).toBe('orange');
-    expect(resolveConditionalValue({ value: 25 }, def)).toBe('green');
-    expect(resolveConditionalValue({ value: -5 }, def)).toBe('gray');
-  });
-
-  it('resolves field reference from condition', () => {
-    const result = resolveConditionalValue(
-      { category: 'A', label: 'Category A' },
-      {
-        condition: {
-          test: { field: 'category', equal: 'A' },
-          field: 'label',
-        },
-        value: 'unknown',
-      },
-    );
-    expect(result).toBe('Category A');
-  });
-
-  it('returns a gradient value intact when the test passes (color channels)', () => {
-    const gradient = {
-      gradient: 'radial' as const,
-      stops: [
-        { offset: 0, color: '#4ade80' },
-        { offset: 1, color: '#15803d' },
-      ],
-    };
-    const result = resolveConditionalValue(
-      { source: 'Renewables', share: 30 },
-      {
-        condition: { test: { field: 'source', equal: 'Renewables' }, value: gradient },
-        value: '#e2e8f0',
-      },
-    );
-    expect(result).toEqual(gradient);
-  });
-
-  it('returns undefined when no condition matches and no default', () => {
-    const result = resolveConditionalValue(
-      { v: 5 },
-      {
-        condition: { test: { field: 'v', gt: 100 }, value: 'high' },
-      },
-    );
-    expect(result).toBeUndefined();
-  });
-
-  it('works with logical combinators in test', () => {
-    const result = resolveConditionalValue(
-      { x: 5, y: 15 },
-      {
-        condition: {
-          test: {
-            and: [
-              { field: 'x', gt: 0 },
-              { field: 'y', gt: 10 },
-            ],
-          },
-          value: 'both-positive',
-        },
-        value: 'nope',
-      },
-    );
-    expect(result).toBe('both-positive');
-  });
-});
-
-describe('isConditionalValueDef', () => {
-  it('returns true for conditional value defs', () => {
-    expect(
-      isConditionalValueDef({
-        condition: { test: { field: 'x', gt: 0 }, value: 'red' },
-        value: 'blue',
-      }),
-    ).toBe(true);
-  });
-
-  it('returns false for regular encoding channels', () => {
-    expect(isConditionalValueDef({ field: 'x', type: 'quantitative' })).toBe(false);
-  });
-
-  it('returns false for null', () => {
-    expect(isConditionalValueDef(null)).toBe(false);
-  });
-
-  it('returns false for primitives', () => {
-    expect(isConditionalValueDef('hello')).toBe(false);
-    expect(isConditionalValueDef(42)).toBe(false);
-  });
-});