@opendata-ai/openchart-engine 8.0.0-rc.12 → 8.0.0-rc.3

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

@@ -0,0 +1,159 @@
+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

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,146 @@
+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

@@ -0,0 +1,127 @@
+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);
+  });
+});