@opendata-ai/openchart-engine 8.0.0-rc.10 → 8.0.0-rc.11

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

@@ -1,129 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { runTimeUnit } from '../timeunit';
-
-describe('runTimeUnit', () => {
-  // Use a specific date: 2024-03-15 14:30:45.123 (Friday)
-  const testDate = new Date(2024, 2, 15, 14, 30, 45, 123);
-  const data = [{ ts: testDate }];
-
-  describe('single time units', () => {
-    it('extracts year', () => {
-      const result = runTimeUnit(data, { timeUnit: 'year', field: 'ts', as: 'y' });
-      expect(result[0].y).toBe(2024);
-    });
-
-    it('extracts quarter', () => {
-      const result = runTimeUnit(data, { timeUnit: 'quarter', field: 'ts', as: 'q' });
-      expect(result[0].q).toBe(1); // March is Q1
-    });
-
-    it('extracts month (0-indexed)', () => {
-      const result = runTimeUnit(data, { timeUnit: 'month', field: 'ts', as: 'm' });
-      expect(result[0].m).toBe(2); // March = 2
-    });
-
-    it('extracts day of week', () => {
-      const result = runTimeUnit(data, { timeUnit: 'day', field: 'ts', as: 'd' });
-      expect(result[0].d).toBe(5); // Friday
-    });
-
-    it('extracts date (day of month)', () => {
-      const result = runTimeUnit(data, { timeUnit: 'date', field: 'ts', as: 'd' });
-      expect(result[0].d).toBe(15);
-    });
-
-    it('extracts hours', () => {
-      const result = runTimeUnit(data, { timeUnit: 'hours', field: 'ts', as: 'h' });
-      expect(result[0].h).toBe(14);
-    });
-
-    it('extracts minutes', () => {
-      const result = runTimeUnit(data, { timeUnit: 'minutes', field: 'ts', as: 'min' });
-      expect(result[0].min).toBe(30);
-    });
-
-    it('extracts seconds', () => {
-      const result = runTimeUnit(data, { timeUnit: 'seconds', field: 'ts', as: 's' });
-      expect(result[0].s).toBe(45);
-    });
-
-    it('extracts milliseconds', () => {
-      const result = runTimeUnit(data, { timeUnit: 'milliseconds', field: 'ts', as: 'ms' });
-      expect(result[0].ms).toBe(123);
-    });
-
-    it('extracts week number', () => {
-      const result = runTimeUnit(data, { timeUnit: 'week', field: 'ts', as: 'w' });
-      expect(typeof result[0].w).toBe('number');
-      expect(result[0].w).toBeGreaterThan(0);
-      expect(result[0].w).toBeLessThanOrEqual(53);
-    });
-
-    it('extracts dayofyear', () => {
-      const result = runTimeUnit(data, { timeUnit: 'dayofyear', field: 'ts', as: 'doy' });
-      expect(typeof result[0].doy).toBe('number');
-      // March 15 is day 75 in a leap year (2024)
-      expect(result[0].doy).toBe(75);
-    });
-  });
-
-  describe('compound time units', () => {
-    it('extracts yearmonth', () => {
-      const result = runTimeUnit(data, { timeUnit: 'yearmonth', field: 'ts', as: 'ym' });
-      expect(result[0].ym).toBe('2024-03');
-    });
-
-    it('extracts yearmonthdate', () => {
-      const result = runTimeUnit(data, { timeUnit: 'yearmonthdate', field: 'ts', as: 'ymd' });
-      expect(result[0].ymd).toBe('2024-03-15');
-    });
-
-    it('extracts monthdate', () => {
-      const result = runTimeUnit(data, { timeUnit: 'monthdate', field: 'ts', as: 'md' });
-      expect(result[0].md).toBe('03-15');
-    });
-
-    it('extracts hoursminutes', () => {
-      const result = runTimeUnit(data, { timeUnit: 'hoursminutes', field: 'ts', as: 'hm' });
-      expect(result[0].hm).toBe('14:30');
-    });
-  });
-
-  describe('date parsing', () => {
-    it('parses ISO string dates', () => {
-      const stringData = [{ ts: '2024-03-15T14:30:00Z' }];
-      const result = runTimeUnit(stringData, { timeUnit: 'year', field: 'ts', as: 'y' });
-      expect(result[0].y).toBe(2024);
-    });
-
-    it('parses numeric timestamps', () => {
-      const numData = [{ ts: testDate.getTime() }];
-      const result = runTimeUnit(numData, { timeUnit: 'year', field: 'ts', as: 'y' });
-      expect(result[0].y).toBe(2024);
-    });
-
-    it('returns null for unparseable dates', () => {
-      const badData = [{ ts: 'not-a-date' }];
-      const result = runTimeUnit(badData, { timeUnit: 'year', field: 'ts', as: 'y' });
-      expect(result[0].y).toBeNull();
-    });
-
-    it('returns null for null values', () => {
-      const nullData = [{ ts: null }];
-      const result = runTimeUnit(nullData, { timeUnit: 'year', field: 'ts', as: 'y' });
-      expect(result[0].y).toBeNull();
-    });
-  });
-
-  it('preserves existing fields', () => {
-    const extraData = [{ ts: testDate, label: 'test' }];
-    const result = runTimeUnit(extraData, { timeUnit: 'year', field: 'ts', as: 'y' });
-    expect(result[0].label).toBe('test');
-    expect(result[0].ts).toBe(testDate);
-  });
-
-  it('handles empty data', () => {
-    const result = runTimeUnit([], { timeUnit: 'year', field: 'ts', as: 'y' });
-    expect(result).toHaveLength(0);
-  });
-});

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

@@ -1,286 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { runTransforms } from '../index';
-
-describe('window transform', () => {
-  it('lag(1) on 5 sorted rows: first row null, rest match previous', () => {
-    const data = [
-      { month: '2024-01', value: 10 },
-      { month: '2024-02', value: 20 },
-      { month: '2024-03', value: 30 },
-      { month: '2024-04', value: 40 },
-      { month: '2024-05', value: 50 },
-    ];
-    const result = runTransforms(data, [
-      {
-        window: [{ op: 'lag', field: 'value', offset: 1, as: 'prev_value' }],
-        sort: [{ field: 'month' }],
-      },
-    ]);
-    expect(result.map((r) => r.prev_value)).toEqual([null, 10, 20, 30, 40]);
-  });
-
-  it('lag(12) on 24 monthly rows: rows 1-12 null, row 13 matches row 1', () => {
-    const data = Array.from({ length: 24 }, (_, i) => {
-      const d = new Date(2023, i, 1);
-      return { month: d.toISOString().slice(0, 7), value: (i + 1) * 100 };
-    });
-    const result = runTransforms(data, [
-      {
-        window: [{ op: 'lag', field: 'value', offset: 12, as: 'prev_year' }],
-        sort: [{ field: 'month' }],
-      },
-    ]);
-    // First 12 rows should be null
-    for (let i = 0; i < 12; i++) {
-      expect(result[i].prev_year).toBe(null);
-    }
-    // Row 13 (index 12) should match row 1's value (100)
-    expect(result[12].prev_year).toBe(100);
-    // Row 24 (index 23) should match row 12's value (1200)
-    expect(result[23].prev_year).toBe(1200);
-  });
-
-  it('pct_change with offset 1 on [100, 110, 121, 133.1]', () => {
-    const data = [
-      { idx: 1, value: 100 },
-      { idx: 2, value: 110 },
-      { idx: 3, value: 121 },
-      { idx: 4, value: 133.1 },
-    ];
-    const result = runTransforms(data, [
-      {
-        window: [{ op: 'pct_change', field: 'value', offset: 1, as: 'pct' }],
-        sort: [{ field: 'idx' }],
-      },
-    ]);
-    expect(result[0].pct).toBe(null);
-    expect(result[1].pct).toBeCloseTo(0.1, 5);
-    expect(result[2].pct).toBeCloseTo(0.1, 5);
-    expect(result[3].pct).toBeCloseTo(0.1, 5);
-  });
-
-  it('pct_change with zero denominator returns null, not Infinity', () => {
-    const data = [
-      { idx: 1, value: 0 },
-      { idx: 2, value: 50 },
-    ];
-    const result = runTransforms(data, [
-      {
-        window: [{ op: 'pct_change', field: 'value', offset: 1, as: 'pct' }],
-        sort: [{ field: 'idx' }],
-      },
-    ]);
-    expect(result[0].pct).toBe(null);
-    expect(result[1].pct).toBe(null); // 0 denominator -> null
-  });
-
-  it('diff on [10, 15, 12, 20]', () => {
-    const data = [
-      { idx: 1, value: 10 },
-      { idx: 2, value: 15 },
-      { idx: 3, value: 12 },
-      { idx: 4, value: 20 },
-    ];
-    const result = runTransforms(data, [
-      {
-        window: [{ op: 'diff', field: 'value', offset: 1, as: 'delta' }],
-        sort: [{ field: 'idx' }],
-      },
-    ]);
-    expect(result.map((r) => r.delta)).toEqual([null, 5, -3, 8]);
-  });
-
-  it('cumsum on [1, 2, 3, 4, 5]', () => {
-    const data = [
-      { idx: 1, value: 1 },
-      { idx: 2, value: 2 },
-      { idx: 3, value: 3 },
-      { idx: 4, value: 4 },
-      { idx: 5, value: 5 },
-    ];
-    const result = runTransforms(data, [
-      {
-        window: [{ op: 'cumsum', field: 'value', as: 'running' }],
-        sort: [{ field: 'idx' }],
-      },
-    ]);
-    expect(result.map((r) => r.running)).toEqual([1, 3, 6, 10, 15]);
-  });
-
-  it('cumsum with nulls [1, null, 3, null, 5] treats nulls as 0', () => {
-    const data = [
-      { idx: 1, value: 1 },
-      { idx: 2, value: null },
-      { idx: 3, value: 3 },
-      { idx: 4, value: null },
-      { idx: 5, value: 5 },
-    ];
-    const result = runTransforms(data, [
-      {
-        window: [{ op: 'cumsum', field: 'value', as: 'running' }],
-        sort: [{ field: 'idx' }],
-      },
-    ]);
-    expect(result.map((r) => r.running)).toEqual([1, 1, 4, 4, 9]);
-  });
-
-  it('rank on values [30, 10, 40, 20] sorted ascending gives ranks [1, 2, 3, 4]', () => {
-    // Input is unsorted; window sorts by 'value' ascending
-    const data = [
-      { id: 'a', value: 30 },
-      { id: 'b', value: 10 },
-      { id: 'c', value: 40 },
-      { id: 'd', value: 20 },
-    ];
-    const result = runTransforms(data, [
-      {
-        window: [{ op: 'rank', field: 'value', as: 'rank' }],
-        sort: [{ field: 'value', order: 'ascending' }],
-      },
-    ]);
-    // Results should be in ORIGINAL input order, so:
-    // a(30) -> rank 3, b(10) -> rank 1, c(40) -> rank 4, d(20) -> rank 2
-    expect(result.map((r) => r.rank)).toEqual([3, 1, 4, 2]);
-  });
-
-  it('first_value on [100, 200, 300] all get 100', () => {
-    const data = [
-      { idx: 1, value: 100 },
-      { idx: 2, value: 200 },
-      { idx: 3, value: 300 },
-    ];
-    const result = runTransforms(data, [
-      {
-        window: [{ op: 'first_value', field: 'value', as: 'first' }],
-        sort: [{ field: 'idx' }],
-      },
-    ]);
-    expect(result.map((r) => r.first)).toEqual([100, 100, 100]);
-  });
-
-  it('groupby partitioning: 2 groups of 3 rows, lag(1) computed independently', () => {
-    const data = [
-      { group: 'A', idx: 1, value: 10 },
-      { group: 'B', idx: 1, value: 100 },
-      { group: 'A', idx: 2, value: 20 },
-      { group: 'B', idx: 2, value: 200 },
-      { group: 'A', idx: 3, value: 30 },
-      { group: 'B', idx: 3, value: 300 },
-    ];
-    const result = runTransforms(data, [
-      {
-        window: [{ op: 'lag', field: 'value', offset: 1, as: 'prev' }],
-        sort: [{ field: 'idx' }],
-        groupby: ['group'],
-      },
-    ]);
-    // Results in original input order
-    // A idx 1 -> null, B idx 1 -> null, A idx 2 -> 10, B idx 2 -> 100, A idx 3 -> 20, B idx 3 -> 200
-    expect(result.map((r) => r.prev)).toEqual([null, null, 10, 100, 20, 200]);
-  });
-
-  it('sorts ISO dates correctly before computing lag', () => {
-    // Input deliberately unsorted
-    const data = [
-      { date: '2024-03-15', value: 300 },
-      { date: '2024-01-10', value: 100 },
-      { date: '2024-02-20', value: 200 },
-    ];
-    const result = runTransforms(data, [
-      {
-        window: [{ op: 'lag', field: 'value', offset: 1, as: 'prev' }],
-        sort: [{ field: 'date' }],
-      },
-    ]);
-    // Sorted order: Jan(100), Feb(200), Mar(300)
-    // Jan -> null, Feb -> 100, Mar -> 200
-    // Original order: Mar, Jan, Feb -> [200, null, 100]
-    expect(result.map((r) => r.prev)).toEqual([200, null, 100]);
-  });
-
-  it('sorts numeric timestamp strings numerically, not lexicographically', () => {
-    // Lexicographic: "9" > "10" but numeric: 9 < 10
-    const data = [
-      { ts: '10', value: 'b' },
-      { ts: '9', value: 'a' },
-      { ts: '100', value: 'c' },
-    ];
-    const result = runTransforms(data, [
-      {
-        window: [{ op: 'lag', field: 'value', offset: 1, as: 'prev' }],
-        sort: [{ field: 'ts' }],
-      },
-    ]);
-    // Numeric sort: 9, 10, 100 -> values: a, b, c
-    // ts=10(b) -> lag is a, ts=9(a) -> lag is null, ts=100(c) -> lag is b
-    expect(result.map((r) => r.prev)).toEqual(['a', null, 'b']);
-  });
-
-  it('lead(1) on 4 rows: last row null, rest match next', () => {
-    const data = [
-      { idx: 1, value: 10 },
-      { idx: 2, value: 20 },
-      { idx: 3, value: 30 },
-      { idx: 4, value: 40 },
-    ];
-    const result = runTransforms(data, [
-      {
-        window: [{ op: 'lead', field: 'value', offset: 1, as: 'next_value' }],
-        sort: [{ field: 'idx' }],
-      },
-    ]);
-    expect(result.map((r) => r.next_value)).toEqual([20, 30, 40, null]);
-  });
-
-  it('rank with tied values uses competition ranking', () => {
-    const data = [
-      { id: 'a', value: 10 },
-      { id: 'b', value: 20 },
-      { id: 'c', value: 10 },
-      { id: 'd', value: 30 },
-    ];
-    const result = runTransforms(data, [
-      {
-        window: [{ op: 'rank', field: 'value', as: 'rank' }],
-        sort: [{ field: 'value', order: 'ascending' }],
-      },
-    ]);
-    // Sorted: a(10), c(10), b(20), d(30). Tied values get same rank.
-    // Original order: a(10)->1, b(20)->3, c(10)->1, d(30)->4
-    expect(result.map((r) => r.rank)).toEqual([1, 3, 1, 4]);
-  });
-
-  it('returns [] for empty data', () => {
-    const result = runTransforms(
-      [],
-      [
-        {
-          window: [{ op: 'lag', field: 'value', offset: 1, as: 'prev' }],
-          sort: [{ field: 'value' }],
-        },
-      ],
-    );
-    expect(result).toEqual([]);
-  });
-
-  it('window chained with filter: window then filter on computed field', () => {
-    const data = [
-      { idx: 1, value: 100 },
-      { idx: 2, value: 110 },
-      { idx: 3, value: 90 },
-      { idx: 4, value: 120 },
-    ];
-    const result = runTransforms(data, [
-      {
-        window: [{ op: 'diff', field: 'value', offset: 1, as: 'delta' }],
-        sort: [{ field: 'idx' }],
-      },
-      {
-        filter: { field: 'delta', gt: 0 },
-      },
-    ]);
-    // Diffs: [null, 10, -20, 30] -> filter gt 0 -> [10, 30]
-    expect(result).toHaveLength(2);
-    expect(result.map((r) => r.delta)).toEqual([10, 30]);
-  });
-});

package/src/transforms/aggregate.ts

@@ -1,131 +0,0 @@
-/**
- * Aggregate transform: groups rows and computes summary statistics.
- *
- * Follows Vega-Lite aggregate transform conventions.
- * Groups input data by the specified fields, then applies aggregate
- * operations (sum, mean, count, etc.) to produce one row per group.
- */
-
-import type { AggregateOp, AggregateTransform, DataRow } from '@opendata-ai/openchart-core';
-
-/**
- * Compute a single aggregate operation over an array of numeric values.
- * Also used by the sort-by-value sugar expansion in compile/spec-sugar.ts.
- */
-export function computeAggregate(op: AggregateOp, values: number[]): number {
-  if (values.length === 0) return 0;
-
-  switch (op) {
-    case 'count':
-      return values.length;
-    case 'sum':
-      return values.reduce((a, b) => a + b, 0);
-    case 'mean': {
-      const sum = values.reduce((a, b) => a + b, 0);
-      return sum / values.length;
-    }
-    case 'median': {
-      const sorted = [...values].sort((a, b) => a - b);
-      const mid = Math.floor(sorted.length / 2);
-      return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
-    }
-    case 'min':
-      return Math.min(...values);
-    case 'max':
-      return Math.max(...values);
-    case 'variance': {
-      if (values.length < 2) return 0;
-      const mean = values.reduce((a, b) => a + b, 0) / values.length;
-      return values.reduce((a, v) => a + (v - mean) ** 2, 0) / values.length;
-    }
-    case 'stdev': {
-      if (values.length < 2) return 0;
-      const m = values.reduce((a, b) => a + b, 0) / values.length;
-      return Math.sqrt(values.reduce((a, v) => a + (v - m) ** 2, 0) / values.length);
-    }
-    case 'q1': {
-      const s = [...values].sort((a, b) => a - b);
-      const i = (s.length - 1) * 0.25;
-      const lo = Math.floor(i);
-      const frac = i - lo;
-      return s[lo] + frac * ((s[lo + 1] ?? s[lo]) - s[lo]);
-    }
-    case 'q3': {
-      const s = [...values].sort((a, b) => a - b);
-      const i = (s.length - 1) * 0.75;
-      const lo = Math.floor(i);
-      const frac = i - lo;
-      return s[lo] + frac * ((s[lo + 1] ?? s[lo]) - s[lo]);
-    }
-    default:
-      return 0;
-  }
-}
-
-/**
- * Build a composite group key from a row's groupby field values.
- */
-function groupKey(row: DataRow, groupby: string[]): string {
-  return groupby.map((f) => String(row[f] ?? '')).join('\x00');
-}
-
-/**
- * Apply an aggregate transform to data rows.
- *
- * Groups rows by the groupby fields, then computes each aggregate
- * operation within each group. Returns one row per group containing
- * the groupby field values plus computed aggregate fields.
- *
- * @param data - Input rows.
- * @param transform - Aggregate transform definition.
- * @returns Aggregated rows (one per group).
- */
-export function runAggregate(data: DataRow[], transform: AggregateTransform): DataRow[] {
-  const { aggregate, groupby } = transform;
-
-  // Group rows by the groupby fields
-  const groups = new Map<string, DataRow[]>();
-  for (const row of data) {
-    const key = groupKey(row, groupby);
-    const existing = groups.get(key);
-    if (existing) {
-      existing.push(row);
-    } else {
-      groups.set(key, [row]);
-    }
-  }
-
-  // Compute aggregates for each group
-  const result: DataRow[] = [];
-  for (const rows of groups.values()) {
-    // Start with groupby field values from the first row in the group
-    const outRow: DataRow = {};
-    for (const field of groupby) {
-      outRow[field] = rows[0][field];
-    }
-
-    // Compute each aggregate operation
-    for (const agg of aggregate) {
-      // distinct counts unique raw values (not just numeric)
-      if (agg.op === 'distinct') {
-        outRow[agg.as] = new Set(rows.map((r) => r[agg.field])).size;
-        continue;
-      }
-
-      const values = rows
-        .map((r) => {
-          // For count, the field value doesn't matter, just count rows
-          if (agg.op === 'count') return 1;
-          const v = Number(r[agg.field]);
-          return Number.isFinite(v) ? v : NaN;
-        })
-        .filter((v) => !Number.isNaN(v));
-
-      outRow[agg.as] = computeAggregate(agg.op, values);
-    }
-
-    result.push(outRow);
-  }
-
-  return result;
-}

package/src/transforms/bin.ts

@@ -1,87 +0,0 @@
-/**
- * Bin transform: discretizes a continuous field into bins.
- *
- * Adds bin start (and optionally bin end) fields to each row.
- */
-
-import type { BinParams, BinTransform, DataRow } from '@opendata-ai/openchart-core';
-
-/**
- * Compute a nice step size for binning.
- */
-function computeStep(extent: [number, number], maxbins: number, nice: boolean): number {
-  const span = extent[1] - extent[0];
-  if (span === 0) return 1;
-
-  let step = span / maxbins;
-
-  if (nice) {
-    // Round to a nice step: 1, 2, 5, 10, 20, 50, etc.
-    const magnitude = 10 ** Math.floor(Math.log10(step));
-    const residual = step / magnitude;
-
-    if (residual <= 1.5) {
-      step = magnitude;
-    } else if (residual <= 3.5) {
-      step = 2 * magnitude;
-    } else if (residual <= 7.5) {
-      step = 5 * magnitude;
-    } else {
-      step = 10 * magnitude;
-    }
-  }
-
-  return step;
-}
-
-/**
- * Apply a bin transform to data rows.
- *
- * Adds one or two fields to each row:
- * - If `as` is a string: adds `as` with the bin start value.
- * - If `as` is [start, end]: adds both bin start and bin end fields.
- *
- * @param data - Input rows.
- * @param transform - Bin transform definition.
- * @returns New rows with binned field(s) added.
- */
-export function runBin(data: DataRow[], transform: BinTransform): DataRow[] {
-  const params: BinParams = transform.bin === true ? {} : transform.bin;
-  const maxbins = params.maxbins ?? 10;
-  const nice = params.nice ?? true;
-  const field = transform.field;
-
-  // Compute extent from data if not provided
-  let extent = params.extent;
-  if (!extent) {
-    let min = Infinity;
-    let max = -Infinity;
-    for (const row of data) {
-      const v = Number(row[field]);
-      if (Number.isFinite(v)) {
-        if (v < min) min = v;
-        if (v > max) max = v;
-      }
-    }
-    extent = [min === Infinity ? 0 : min, max === -Infinity ? 0 : max];
-  }
-
-  const step = params.step ?? computeStep(extent, maxbins, nice);
-  const [startAs, endAs] = Array.isArray(transform.as) ? transform.as : [transform.as, undefined];
-
-  return data.map((row) => {
-    const v = Number(row[field]);
-    const newRow = { ...row };
-
-    if (!Number.isFinite(v)) {
-      newRow[startAs] = null;
-      if (endAs) newRow[endAs] = null;
-    } else {
-      const binStart = Math.floor((v - extent![0]) / step) * step + extent![0];
-      newRow[startAs] = binStart;
-      if (endAs) newRow[endAs] = binStart + step;
-    }
-
-    return newRow;
-  });
-}

package/src/transforms/calculate.ts

@@ -1,60 +0,0 @@
-/**
- * Calculate transform: adds a computed field to each row.
- *
- * Supports arithmetic operations on fields and constant values.
- */
-
-import type { CalculateExpression, CalculateTransform, DataRow } from '@opendata-ai/openchart-core';
-
-/**
- * Evaluate a calculate expression against a datum.
- */
-function evaluateExpression(datum: DataRow, expr: CalculateExpression): number {
-  const fieldValue = Number(datum[expr.field]);
-
-  // Unary operations (single field)
-  switch (expr.op) {
-    case 'abs':
-      return Math.abs(fieldValue);
-    case 'round':
-      return Math.round(fieldValue);
-    case 'floor':
-      return Math.floor(fieldValue);
-    case 'ceil':
-      return Math.ceil(fieldValue);
-    case 'log':
-      return Math.log(fieldValue);
-    case 'sqrt':
-      return Math.sqrt(fieldValue);
-  }
-
-  // Binary operations (field + field2 or field + value)
-  const operand = expr.field2 !== undefined ? Number(datum[expr.field2]) : (expr.value ?? 0);
-
-  switch (expr.op) {
-    case '+':
-      return fieldValue + operand;
-    case '-':
-      return fieldValue - operand;
-    case '*':
-      return fieldValue * operand;
-    case '/':
-      return operand === 0 ? NaN : fieldValue / operand;
-  }
-}
-
-/**
- * Apply a calculate transform to data rows.
- *
- * Adds a new field with the computed value to each row.
- *
- * @param data - Input rows.
- * @param transform - Calculate transform definition.
- * @returns New rows with the calculated field added.
- */
-export function runCalculate(data: DataRow[], transform: CalculateTransform): DataRow[] {
-  return data.map((row) => ({
-    ...row,
-    [transform.as]: evaluateExpression(row, transform.calculate),
-  }));
-}