@opendata-ai/openchart-engine 6.0.0 → 6.1.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,109 @@
+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 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);
+  });
+});

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

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+import { runFilter } from '../filter';
+
+describe('runFilter', () => {
+  const data = [
+    { name: 'Alice', age: 25, city: 'NYC' },
+    { name: 'Bob', age: 30, city: 'LA' },
+    { name: 'Carol', age: 35, city: 'NYC' },
+    { name: 'Dave', age: 40, city: 'LA' },
+  ];
+
+  it('filters by field equality', () => {
+    const result = runFilter(data, { field: 'city', equal: 'NYC' });
+    expect(result).toHaveLength(2);
+    expect(result.map((r) => r.name)).toEqual(['Alice', 'Carol']);
+  });
+
+  it('filters by numeric comparison', () => {
+    const result = runFilter(data, { field: 'age', gt: 30 });
+    expect(result).toHaveLength(2);
+    expect(result.map((r) => r.name)).toEqual(['Carol', 'Dave']);
+  });
+
+  it('filters with logical AND', () => {
+    const result = runFilter(data, {
+      and: [
+        { field: 'city', equal: 'LA' },
+        { field: 'age', gte: 35 },
+      ],
+    });
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe('Dave');
+  });
+
+  it('filters with logical OR', () => {
+    const result = runFilter(data, {
+      or: [
+        { field: 'name', equal: 'Alice' },
+        { field: 'name', equal: 'Dave' },
+      ],
+    });
+    expect(result).toHaveLength(2);
+  });
+
+  it('returns empty array when no rows match', () => {
+    const result = runFilter(data, { field: 'age', gt: 100 });
+    expect(result).toHaveLength(0);
+  });
+
+  it('returns all rows when all match', () => {
+    const result = runFilter(data, { field: 'age', gt: 0 });
+    expect(result).toHaveLength(4);
+  });
+
+  it('handles empty data', () => {
+    const result = runFilter([], { field: 'age', gt: 0 });
+    expect(result).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest';
+import { runTransforms } from '../index';
+
+describe('runTransforms', () => {
+  it('runs transforms in order', () => {
+    const data = [
+      { name: 'Alice', value: 10 },
+      { name: 'Bob', value: 20 },
+      { name: 'Carol', value: 30 },
+    ];
+
+    // First filter, then calculate on the filtered result
+    const result = runTransforms(data, [
+      { filter: { field: 'value', gte: 15 } },
+      { calculate: { op: '*', field: 'value', value: 2 }, as: 'doubled' },
+    ]);
+
+    expect(result).toHaveLength(2);
+    expect(result[0].name).toBe('Bob');
+    expect(result[0].doubled).toBe(40);
+    expect(result[1].name).toBe('Carol');
+    expect(result[1].doubled).toBe(60);
+  });
+
+  it('applies filter after calculate', () => {
+    const data = [{ value: 3 }, { value: 7 }, { value: 12 }];
+
+    // Calculate first, then filter on the calculated field
+    const result = runTransforms(data, [
+      { calculate: { op: '*', field: 'value', value: 10 }, as: 'scaled' },
+      { filter: { field: 'scaled', gt: 50 } },
+    ]);
+
+    expect(result).toHaveLength(2);
+    expect(result[0].scaled).toBe(70);
+    expect(result[1].scaled).toBe(120);
+  });
+
+  it('chains bin and filter', () => {
+    const data = [{ value: 5 }, { value: 15 }, { value: 25 }, { value: 35 }];
+
+    const result = runTransforms(data, [
+      { bin: { step: 10, extent: [0, 40] }, field: 'value', as: 'binned' },
+      { filter: { field: 'binned', gte: 20 } },
+    ]);
+
+    expect(result).toHaveLength(2);
+    expect(result[0].value).toBe(25);
+    expect(result[1].value).toBe(35);
+  });
+
+  it('chains timeUnit and filter', () => {
+    const data = [
+      { date: new Date(2024, 0, 15) }, // January
+      { date: new Date(2024, 5, 15) }, // June
+      { date: new Date(2024, 11, 15) }, // December
+    ];
+
+    const result = runTransforms(data, [
+      { timeUnit: 'month' as const, field: 'date', as: 'month' },
+      { filter: { field: 'month', gte: 5 } }, // June onwards (0-indexed)
+    ]);
+
+    expect(result).toHaveLength(2);
+  });
+
+  it('returns original data for empty transform array', () => {
+    const data = [{ x: 1 }];
+    const result = runTransforms(data, []);
+    expect(result).toEqual(data);
+    expect(result).toBe(data); // Same reference since no transforms applied
+  });
+
+  it('handles multiple filters in sequence', () => {
+    const data = [
+      { x: 1, y: 10 },
+      { x: 5, y: 20 },
+      { x: 8, y: 30 },
+      { x: 12, y: 40 },
+    ];
+
+    const result = runTransforms(data, [
+      { filter: { field: 'x', gt: 3 } },
+      { filter: { field: 'y', lt: 35 } },
+    ]);
+
+    // x>3 keeps: {5,20}, {8,30}, {12,40}
+    // y<35 keeps: {5,20}, {8,30}
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual({ x: 5, y: 20 });
+    expect(result[1]).toEqual({ x: 8, y: 30 });
+  });
+});

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

@@ -0,0 +1,176 @@
+import { describe, expect, it } from 'vitest';
+import { evaluatePredicate } from '../predicates';
+
+describe('evaluatePredicate', () => {
+  describe('FieldPredicate: equal', () => {
+    it('matches equal string value', () => {
+      expect(evaluatePredicate({ name: 'Alice' }, { field: 'name', equal: 'Alice' })).toBe(true);
+    });
+
+    it('rejects non-equal value', () => {
+      expect(evaluatePredicate({ name: 'Bob' }, { field: 'name', equal: 'Alice' })).toBe(false);
+    });
+
+    it('matches equal numeric value', () => {
+      expect(evaluatePredicate({ age: 30 }, { field: 'age', equal: 30 })).toBe(true);
+    });
+  });
+
+  describe('FieldPredicate: lt/lte/gt/gte', () => {
+    it('lt: value less than threshold', () => {
+      expect(evaluatePredicate({ v: 5 }, { field: 'v', lt: 10 })).toBe(true);
+      expect(evaluatePredicate({ v: 10 }, { field: 'v', lt: 10 })).toBe(false);
+    });
+
+    it('lte: value less than or equal', () => {
+      expect(evaluatePredicate({ v: 10 }, { field: 'v', lte: 10 })).toBe(true);
+      expect(evaluatePredicate({ v: 11 }, { field: 'v', lte: 10 })).toBe(false);
+    });
+
+    it('gt: value greater than threshold', () => {
+      expect(evaluatePredicate({ v: 15 }, { field: 'v', gt: 10 })).toBe(true);
+      expect(evaluatePredicate({ v: 10 }, { field: 'v', gt: 10 })).toBe(false);
+    });
+
+    it('gte: value greater than or equal', () => {
+      expect(evaluatePredicate({ v: 10 }, { field: 'v', gte: 10 })).toBe(true);
+      expect(evaluatePredicate({ v: 9 }, { field: 'v', gte: 10 })).toBe(false);
+    });
+  });
+
+  describe('FieldPredicate: range', () => {
+    it('includes values within range', () => {
+      expect(evaluatePredicate({ v: 5 }, { field: 'v', range: [1, 10] })).toBe(true);
+    });
+
+    it('includes boundary values', () => {
+      expect(evaluatePredicate({ v: 1 }, { field: 'v', range: [1, 10] })).toBe(true);
+      expect(evaluatePredicate({ v: 10 }, { field: 'v', range: [1, 10] })).toBe(true);
+    });
+
+    it('excludes values outside range', () => {
+      expect(evaluatePredicate({ v: 0 }, { field: 'v', range: [1, 10] })).toBe(false);
+      expect(evaluatePredicate({ v: 11 }, { field: 'v', range: [1, 10] })).toBe(false);
+    });
+  });
+
+  describe('FieldPredicate: oneOf', () => {
+    it('matches values in the set', () => {
+      expect(evaluatePredicate({ c: 'red' }, { field: 'c', oneOf: ['red', 'blue'] })).toBe(true);
+    });
+
+    it('rejects values not in the set', () => {
+      expect(evaluatePredicate({ c: 'green' }, { field: 'c', oneOf: ['red', 'blue'] })).toBe(false);
+    });
+  });
+
+  describe('FieldPredicate: valid', () => {
+    it('valid=true passes for normal values', () => {
+      expect(evaluatePredicate({ v: 42 }, { field: 'v', valid: true })).toBe(true);
+      expect(evaluatePredicate({ v: 'hello' }, { field: 'v', valid: true })).toBe(true);
+    });
+
+    it('valid=true rejects null/undefined/NaN', () => {
+      expect(evaluatePredicate({ v: null }, { field: 'v', valid: true })).toBe(false);
+      expect(evaluatePredicate({ v: undefined }, { field: 'v', valid: true })).toBe(false);
+      expect(evaluatePredicate({ v: NaN }, { field: 'v', valid: true })).toBe(false);
+    });
+
+    it('valid=false passes for null/undefined/NaN', () => {
+      expect(evaluatePredicate({ v: null }, { field: 'v', valid: false })).toBe(true);
+      expect(evaluatePredicate({ v: NaN }, { field: 'v', valid: false })).toBe(true);
+    });
+
+    it('valid=false rejects normal values', () => {
+      expect(evaluatePredicate({ v: 42 }, { field: 'v', valid: false })).toBe(false);
+    });
+  });
+
+  describe('LogicalAnd', () => {
+    it('passes when all conditions match', () => {
+      const pred = {
+        and: [
+          { field: 'v', gt: 5 },
+          { field: 'v', lt: 15 },
+        ],
+      };
+      expect(evaluatePredicate({ v: 10 }, pred)).toBe(true);
+    });
+
+    it('fails when any condition fails', () => {
+      const pred = {
+        and: [
+          { field: 'v', gt: 5 },
+          { field: 'v', lt: 15 },
+        ],
+      };
+      expect(evaluatePredicate({ v: 20 }, pred)).toBe(false);
+    });
+  });
+
+  describe('LogicalOr', () => {
+    it('passes when any condition matches', () => {
+      const pred = {
+        or: [
+          { field: 'c', equal: 'red' },
+          { field: 'c', equal: 'blue' },
+        ],
+      };
+      expect(evaluatePredicate({ c: 'blue' }, pred)).toBe(true);
+    });
+
+    it('fails when no condition matches', () => {
+      const pred = {
+        or: [
+          { field: 'c', equal: 'red' },
+          { field: 'c', equal: 'blue' },
+        ],
+      };
+      expect(evaluatePredicate({ c: 'green' }, pred)).toBe(false);
+    });
+  });
+
+  describe('LogicalNot', () => {
+    it('inverts a passing condition', () => {
+      expect(evaluatePredicate({ v: 5 }, { not: { field: 'v', gt: 10 } })).toBe(true);
+    });
+
+    it('inverts a failing condition', () => {
+      expect(evaluatePredicate({ v: 15 }, { not: { field: 'v', gt: 10 } })).toBe(false);
+    });
+  });
+
+  describe('nested logical combinators', () => {
+    it('handles and inside or', () => {
+      const pred = {
+        or: [
+          {
+            and: [
+              { field: 'x', gt: 0 },
+              { field: 'x', lt: 10 },
+            ],
+          },
+          { field: 'x', equal: 100 },
+        ],
+      };
+      expect(evaluatePredicate({ x: 5 }, pred)).toBe(true);
+      expect(evaluatePredicate({ x: 100 }, pred)).toBe(true);
+      expect(evaluatePredicate({ x: 50 }, pred)).toBe(false);
+    });
+
+    it('handles not inside and', () => {
+      const pred = {
+        and: [{ field: 'x', gt: 0 }, { not: { field: 'x', equal: 5 } }],
+      };
+      expect(evaluatePredicate({ x: 3 }, pred)).toBe(true);
+      expect(evaluatePredicate({ x: 5 }, pred)).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('missing field returns true for no-op predicate', () => {
+      // A field predicate with no comparison operators defaults to true
+      expect(evaluatePredicate({ other: 1 }, { field: 'v' })).toBe(true);
+    });
+  });
+});