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

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

@@ -1,202 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { runFilter } from '../filter';
-import { runTransforms } from '../index';
-
-/**
- * Generate monthly rows: one row per month for `months` months starting from `startDate`.
- */
-function monthlyData(startDate: string, months: number) {
-  const rows = [];
-  const start = new Date(startDate);
-  for (let i = 0; i < months; i++) {
-    const d = new Date(start);
-    d.setMonth(d.getMonth() + i);
-    rows.push({ date: d.toISOString().slice(0, 10), value: i + 1 });
-  }
-  return rows;
-}
-
-/**
- * Generate daily rows: one row per day for `days` days starting from `startDate`.
- */
-function dailyData(startDate: string, days: number) {
-  const rows = [];
-  const start = new Date(startDate);
-  for (let i = 0; i < days; i++) {
-    const d = new Date(start);
-    d.setDate(d.getDate() + i);
-    rows.push({ date: d.toISOString().slice(0, 10), value: i + 1 });
-  }
-  return rows;
-}
-
-describe('relative-time filter', () => {
-  it('last 1 year from max: 60 monthly rows, gte anchor max offset -1 year returns ~12 rows', () => {
-    const data = monthlyData('2020-01-01', 60); // Jan 2020 through Dec 2024
-    const result = runFilter(data, {
-      field: 'date',
-      gte: { anchor: 'max', offset: -1, unit: 'year' },
-    });
-    // Max date is 2024-12-01, minus 1 year = 2023-12-01
-    // Should include Dec 2023 through Dec 2024 = 13 rows
-    expect(result.length).toBeGreaterThanOrEqual(12);
-    expect(result.length).toBeLessThanOrEqual(13);
-    // All returned dates should be >= 2023-12-01
-    for (const row of result) {
-      expect(new Date(row.date as string).getTime()).toBeGreaterThanOrEqual(
-        new Date('2023-12-01').getTime(),
-      );
-    }
-  });
-
-  it('last 3 years from max: 60 monthly rows, offset -3 returns ~36 rows', () => {
-    const data = monthlyData('2020-01-01', 60);
-    const result = runFilter(data, {
-      field: 'date',
-      gte: { anchor: 'max', offset: -3, unit: 'year' },
-    });
-    // Max is 2024-12-01, minus 3 years = 2021-12-01
-    // Dec 2021 through Dec 2024 = 37 rows
-    expect(result.length).toBeGreaterThanOrEqual(36);
-    expect(result.length).toBeLessThanOrEqual(37);
-  });
-
-  it('last 30 days: 90 daily rows, offset -30 day returns 30-31 rows', () => {
-    const data = dailyData('2024-01-01', 90);
-    const result = runFilter(data, {
-      field: 'date',
-      gte: { anchor: 'max', offset: -30, unit: 'day' },
-    });
-    expect(result.length).toBeGreaterThanOrEqual(30);
-    expect(result.length).toBeLessThanOrEqual(31);
-  });
-
-  it('anchor min + offset: lte anchor min offset +2 year returns rows within 2 years of earliest', () => {
-    const data = monthlyData('2020-01-01', 60);
-    const result = runFilter(data, {
-      field: 'date',
-      lte: { anchor: 'min', offset: 2, unit: 'year' },
-    });
-    // Min is 2020-01-01, plus 2 years = 2022-01-01
-    // Jan 2020 through Jan 2022 = 25 rows
-    expect(result.length).toBeGreaterThanOrEqual(24);
-    expect(result.length).toBeLessThanOrEqual(25);
-    for (const row of result) {
-      expect(new Date(row.date as string).getTime()).toBeLessThanOrEqual(
-        new Date('2022-01-01').getTime(),
-      );
-    }
-  });
-
-  it('quarter unit: offset -4 quarter returns last ~4 quarters', () => {
-    // Generate quarterly data (every 3 months)
-    const data = [];
-    const start = new Date('2020-01-01');
-    for (let i = 0; i < 20; i++) {
-      const d = new Date(start);
-      d.setMonth(d.getMonth() + i * 3);
-      data.push({ date: d.toISOString().slice(0, 10), value: i + 1 });
-    }
-    const result = runFilter(data, {
-      field: 'date',
-      gte: { anchor: 'max', offset: -4, unit: 'quarter' },
-    });
-    // 4 quarters back from max = ~4-5 rows of quarterly data
-    expect(result.length).toBeGreaterThanOrEqual(4);
-    expect(result.length).toBeLessThanOrEqual(5);
-  });
-
-  it('non-ISO dates: data with timestamp numbers resolves correctly', () => {
-    // Use numeric timestamps instead of date strings
-    const baseDate = new Date('2024-01-01').getTime();
-    const dayMs = 86400000;
-    const data = Array.from({ length: 90 }, (_, i) => ({
-      date: baseDate + i * dayMs,
-      value: i,
-    }));
-    const result = runFilter(data, {
-      field: 'date',
-      gte: { anchor: 'max', offset: -30, unit: 'day' },
-    });
-    expect(result.length).toBeGreaterThanOrEqual(30);
-    expect(result.length).toBeLessThanOrEqual(31);
-  });
-
-  it('empty dataset returns [] without throwing', () => {
-    const result = runFilter([], {
-      field: 'date',
-      gte: { anchor: 'max', offset: -1, unit: 'year' },
-    });
-    expect(result).toEqual([]);
-  });
-
-  it('single row: returns that row when anchor matches', () => {
-    const data = [{ date: '2024-06-15', value: 42 }];
-    const result = runFilter(data, {
-      field: 'date',
-      gte: { anchor: 'max', offset: -1, unit: 'year' },
-    });
-    // The single row is both min and max; subtracting 1 year puts the threshold before it
-    expect(result).toHaveLength(1);
-    expect(result[0].value).toBe(42);
-  });
-
-  it('chained transforms: calculate first, then relative filter works on post-transform data', () => {
-    const data = monthlyData('2020-01-01', 60);
-    const result = runTransforms(data, [
-      // Copy date field to a new field (identity via multiply by 1 won't work for dates,
-      // so we just verify the filter operates on the same data)
-      {
-        filter: {
-          field: 'date',
-          gte: { anchor: 'max', offset: -1, unit: 'year' },
-        },
-      },
-    ]);
-    expect(result.length).toBeGreaterThanOrEqual(12);
-    expect(result.length).toBeLessThanOrEqual(13);
-  });
-
-  it('range predicate with two relative refs', () => {
-    const data = monthlyData('2020-01-01', 60);
-    const maxDate = new Date(data[data.length - 1].date as string);
-    const loBound = new Date(maxDate);
-    loBound.setFullYear(loBound.getFullYear() - 2);
-    const hiBound = new Date(maxDate);
-    hiBound.setFullYear(hiBound.getFullYear() - 1);
-
-    const result = runFilter(data, {
-      field: 'date',
-      range: [
-        { anchor: 'max', offset: -2, unit: 'year' },
-        { anchor: 'max', offset: -1, unit: 'year' },
-      ],
-    });
-    expect(result.length).toBeGreaterThanOrEqual(12);
-    expect(result.length).toBeLessThanOrEqual(13);
-    for (const row of result) {
-      const ts = new Date(row.date as string).getTime();
-      expect(ts).toBeGreaterThanOrEqual(loBound.getTime());
-      expect(ts).toBeLessThanOrEqual(hiBound.getTime());
-    }
-  });
-
-  it('logical AND with relative ref and static filter: both applied', () => {
-    const data = monthlyData('2020-01-01', 60).map((r, i) => ({
-      ...r,
-      category: i % 2 === 0 ? 'A' : 'B',
-    }));
-    const result = runFilter(data, {
-      and: [
-        { field: 'date', gte: { anchor: 'max', offset: -1, unit: 'year' } },
-        { field: 'category', equal: 'A' },
-      ],
-    });
-    // ~12-13 rows in last year, roughly half are category A
-    expect(result.length).toBeGreaterThanOrEqual(5);
-    expect(result.length).toBeLessThanOrEqual(7);
-    for (const row of result) {
-      expect(row.category).toBe('A');
-    }
-  });
-});

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

@@ -1,59 +0,0 @@
-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__/fold.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { runFold } from '../fold';
-
-describe('runFold', () => {
-  const data = [
-    { country: 'US', gold: 10, silver: 20, bronze: 30 },
-    { country: 'UK', gold: 5, silver: 15, bronze: 25 },
-  ];
-
-  it('folds two columns with default key/value names', () => {
-    const result = runFold(data, {
-      fold: ['gold', 'silver'],
-    });
-
-    expect(result).toHaveLength(4); // 2 rows x 2 fold fields
-    expect(result[0]).toEqual({ country: 'US', bronze: 30, key: 'gold', value: 10 });
-    expect(result[1]).toEqual({ country: 'US', bronze: 30, key: 'silver', value: 20 });
-    expect(result[2]).toEqual({ country: 'UK', bronze: 25, key: 'gold', value: 5 });
-    expect(result[3]).toEqual({ country: 'UK', bronze: 25, key: 'silver', value: 15 });
-  });
-
-  it('folds three columns', () => {
-    const result = runFold(data, {
-      fold: ['gold', 'silver', 'bronze'],
-    });
-
-    expect(result).toHaveLength(6); // 2 rows x 3 fold fields
-    // First row's fold outputs
-    expect(result[0].key).toBe('gold');
-    expect(result[0].value).toBe(10);
-    expect(result[1].key).toBe('silver');
-    expect(result[1].value).toBe(20);
-    expect(result[2].key).toBe('bronze');
-    expect(result[2].value).toBe(30);
-  });
-
-  it('uses custom as names', () => {
-    const result = runFold(data, {
-      fold: ['gold', 'silver'],
-      as: ['medal', 'count'],
-    });
-
-    expect(result[0].medal).toBe('gold');
-    expect(result[0].count).toBe(10);
-    expect(result[1].medal).toBe('silver');
-    expect(result[1].count).toBe(20);
-    // Default key/value shouldn't be present
-    expect(result[0].key).toBeUndefined();
-    expect(result[0].value).toBeUndefined();
-  });
-
-  it('preserves non-fold fields', () => {
-    const result = runFold(data, {
-      fold: ['gold'],
-    });
-
-    // country and bronze are non-fold fields
-    expect(result[0].country).toBe('US');
-    expect(result[0].bronze).toBe(30);
-    // gold should not be a direct field (it's now key/value)
-    expect(result[0].gold).toBeUndefined();
-  });
-
-  it('handles undefined fold field values', () => {
-    const sparse = [{ name: 'test', a: 1 }]; // no 'b' field
-    const result = runFold(sparse, {
-      fold: ['a', 'b'],
-    });
-
-    expect(result).toHaveLength(2);
-    expect(result[0].value).toBe(1);
-    expect(result[1].value).toBeUndefined();
-  });
-
-  it('handles empty data', () => {
-    const result = runFold([], { fold: ['gold', 'silver'] });
-    expect(result).toHaveLength(0);
-  });
-});

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

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

@@ -1,193 +0,0 @@
-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);
-    });
-
-    it('matches string value against numeric predicate via loose equality', () => {
-      // CSV/JSON parsing often produces string values for numeric fields
-      expect(evaluatePredicate({ id: '181' }, { field: 'id', equal: 181 })).toBe(true);
-    });
-
-    it('matches numeric value against string predicate via loose equality', () => {
-      expect(evaluatePredicate({ id: 181 }, { field: 'id', equal: '181' })).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);
-    });
-
-    it('matches string value against numeric oneOf via loose equality', () => {
-      expect(evaluatePredicate({ id: '181' }, { field: 'id', oneOf: [181, 200] })).toBe(true);
-    });
-
-    it('rejects value not in numeric oneOf set', () => {
-      expect(evaluatePredicate({ id: '999' }, { field: 'id', oneOf: [181, 200] })).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);
-    });
-  });
-});