@opendata-ai/openchart-engine 6.25.4 → 6.27.0

package/src/tilemap/layout.ts

@@ -0,0 +1,172 @@
+/**
+ * US state tile grid layout computation.
+ *
+ * Defines the fixed grid positions for US state tiles (12 columns x 8 rows)
+ * and computes pixel positions from a given available area.
+ */
+
+export const US_STATE_TILES: Array<{ state: string; col: number; row: number }> = [
+  // Row 0
+  { state: 'ME', col: 10, row: 0 },
+
+  // Row 1
+  { state: 'VT', col: 9, row: 1 },
+  { state: 'NH', col: 10, row: 1 },
+
+  // Row 2
+  { state: 'WA', col: 0, row: 2 },
+  { state: 'ID', col: 1, row: 2 },
+  { state: 'MT', col: 2, row: 2 },
+  { state: 'ND', col: 3, row: 2 },
+  { state: 'MN', col: 4, row: 2 },
+  { state: 'WI', col: 5, row: 2 },
+  { state: 'MI', col: 6, row: 2 },
+  { state: 'NY', col: 8, row: 2 },
+  { state: 'MA', col: 9, row: 2 },
+
+  // Row 3
+  { state: 'OR', col: 0, row: 3 },
+  { state: 'NV', col: 1, row: 3 },
+  { state: 'WY', col: 2, row: 3 },
+  { state: 'SD', col: 3, row: 3 },
+  { state: 'IA', col: 4, row: 3 },
+  { state: 'IL', col: 5, row: 3 },
+  { state: 'IN', col: 6, row: 3 },
+  { state: 'OH', col: 7, row: 3 },
+  { state: 'PA', col: 8, row: 3 },
+  { state: 'NJ', col: 9, row: 3 },
+  { state: 'CT', col: 10, row: 3 },
+
+  // Row 4
+  { state: 'CA', col: 0, row: 4 },
+  { state: 'UT', col: 1, row: 4 },
+  { state: 'CO', col: 2, row: 4 },
+  { state: 'NE', col: 3, row: 4 },
+  { state: 'MO', col: 4, row: 4 },
+  { state: 'KY', col: 5, row: 4 },
+  { state: 'WV', col: 6, row: 4 },
+  { state: 'VA', col: 7, row: 4 },
+  { state: 'MD', col: 8, row: 4 },
+  { state: 'DE', col: 9, row: 4 },
+  { state: 'RI', col: 10, row: 4 },
+
+  // Row 5
+  { state: 'AZ', col: 1, row: 5 },
+  { state: 'NM', col: 2, row: 5 },
+  { state: 'KS', col: 3, row: 5 },
+  { state: 'AR', col: 4, row: 5 },
+  { state: 'TN', col: 5, row: 5 },
+  { state: 'NC', col: 6, row: 5 },
+  { state: 'SC', col: 7, row: 5 },
+  { state: 'DC', col: 8, row: 5 },
+
+  // Row 6
+  { state: 'AK', col: 0, row: 6 },
+  { state: 'OK', col: 3, row: 6 },
+  { state: 'LA', col: 4, row: 6 },
+  { state: 'MS', col: 5, row: 6 },
+  { state: 'AL', col: 6, row: 6 },
+  { state: 'GA', col: 7, row: 6 },
+
+  // Row 7
+  { state: 'HI', col: 1, row: 7 },
+  { state: 'TX', col: 3, row: 7 },
+  { state: 'FL', col: 7, row: 7 },
+];
+
+export const STATE_CODE_SET = new Set(US_STATE_TILES.map((t) => t.state));
+
+export const STATE_NAMES: Record<string, string> = {
+  AL: 'Alabama',
+  AK: 'Alaska',
+  AZ: 'Arizona',
+  AR: 'Arkansas',
+  CA: 'California',
+  CO: 'Colorado',
+  CT: 'Connecticut',
+  DE: 'Delaware',
+  DC: 'District of Columbia',
+  FL: 'Florida',
+  GA: 'Georgia',
+  HI: 'Hawaii',
+  ID: 'Idaho',
+  IL: 'Illinois',
+  IN: 'Indiana',
+  IA: 'Iowa',
+  KS: 'Kansas',
+  KY: 'Kentucky',
+  LA: 'Louisiana',
+  ME: 'Maine',
+  MD: 'Maryland',
+  MA: 'Massachusetts',
+  MI: 'Michigan',
+  MN: 'Minnesota',
+  MS: 'Mississippi',
+  MO: 'Missouri',
+  MT: 'Montana',
+  NE: 'Nebraska',
+  NV: 'Nevada',
+  NH: 'New Hampshire',
+  NJ: 'New Jersey',
+  NM: 'New Mexico',
+  NY: 'New York',
+  NC: 'North Carolina',
+  ND: 'North Dakota',
+  OH: 'Ohio',
+  OK: 'Oklahoma',
+  OR: 'Oregon',
+  PA: 'Pennsylvania',
+  RI: 'Rhode Island',
+  SC: 'South Carolina',
+  SD: 'South Dakota',
+  TN: 'Tennessee',
+  TX: 'Texas',
+  UT: 'Utah',
+  VT: 'Vermont',
+  VA: 'Virginia',
+  WA: 'Washington',
+  WV: 'West Virginia',
+  WI: 'Wisconsin',
+  WY: 'Wyoming',
+};
+
+const GRID_COLS = 12;
+const GRID_ROWS = 8;
+
+export interface TilePositions {
+  tileSize: number;
+  gap: number;
+  positions: Map<string, { x: number; y: number }>;
+  gridWidth: number;
+  gridHeight: number;
+}
+
+/**
+ * Compute pixel positions for all US state tiles.
+ *
+ * Calculates the largest tile size that fits the available area,
+ * preserving the grid's aspect ratio and returning a map of
+ * state codes to pixel coordinates.
+ */
+export function computeTilePositions(
+  availableWidth: number,
+  availableHeight: number,
+  gap = 4,
+): TilePositions {
+  const maxTileW = (availableWidth - gap * (GRID_COLS - 1)) / GRID_COLS;
+  const maxTileH = (availableHeight - gap * (GRID_ROWS - 1)) / GRID_ROWS;
+  const tileSize = Math.max(1, Math.floor(Math.min(maxTileW, maxTileH)));
+
+  const gridWidth = tileSize * GRID_COLS + gap * (GRID_COLS - 1);
+  const gridHeight = tileSize * GRID_ROWS + gap * (GRID_ROWS - 1);
+
+  const positions = new Map<string, { x: number; y: number }>();
+  for (const { state, col, row } of US_STATE_TILES) {
+    positions.set(state, {
+      x: col * (tileSize + gap),
+      y: row * (tileSize + gap),
+    });
+  }
+
+  return { tileSize, gap, positions, gridWidth, gridHeight };
+}

package/src/tilemap/types.ts

@@ -0,0 +1,32 @@
+/**
+ * Internal normalized tilemap spec type used by the compilation pipeline.
+ *
+ * This mirrors NormalizedSankeySpec: all optional fields have been filled
+ * with sensible defaults. It's an engine implementation detail, not a public contract.
+ */
+
+import type {
+  AnimationSpec,
+  DarkMode,
+  LegendConfig,
+  ThemeConfig,
+  TileMapEncoding,
+  TileMapPalette,
+} from '@opendata-ai/openchart-core';
+
+import type { NormalizedChrome } from '../compiler/types';
+
+/** A TileMapSpec with all optional fields filled with defaults. */
+export interface NormalizedTileMapSpec {
+  type: 'tilemap';
+  data: Record<string, unknown>[];
+  encoding: TileMapEncoding;
+  palette: TileMapPalette;
+  chrome: NormalizedChrome;
+  legend?: LegendConfig;
+  theme: ThemeConfig;
+  darkMode: DarkMode;
+  watermark: boolean;
+  animation?: AnimationSpec;
+  valueFormat?: string;
+}

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

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

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