@opencorestack/opengridx 2.1.0 → 3.0.1

package/lib/utils/export/groupedExport.test.ts

@@ -1,144 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { exportToCsv, exportToJson } from './index';
-import type { GridColDef, GridGroupedExportRow, GridRowModel } from '../../types';
-
-// --- shared fixtures ---
-
-type Row = GridRowModel & { id: number; dept: string; salary: number };
-
-const columns: GridColDef<Row>[] = [
-    { field: 'dept', headerName: 'Department' },
-    { field: 'salary', headerName: 'Salary', type: 'number' },
-];
-
-const flatRows: Row[] = [
-    { id: 1, dept: 'Engineering', salary: 90000 },
-    { id: 2, dept: 'Engineering', salary: 85000 },
-    { id: 3, dept: 'Marketing',   salary: 70000 },
-];
-
-const groupedRows: GridGroupedExportRow[] = [
-    { type: 'group-header', depth: 0, groupField: 'dept', groupValue: 'Engineering' },
-    { type: 'leaf', depth: 1, row: { id: 1, dept: 'Engineering', salary: 90000 } },
-    { type: 'leaf', depth: 1, row: { id: 2, dept: 'Engineering', salary: 85000 } },
-    { type: 'group-subtotal', depth: 0, groupField: 'dept', groupValue: 'Engineering', aggregatedValues: { salary: 175000 } },
-    { type: 'group-header', depth: 0, groupField: 'dept', groupValue: 'Marketing' },
-    { type: 'leaf', depth: 1, row: { id: 3, dept: 'Marketing', salary: 70000 } },
-    { type: 'group-subtotal', depth: 0, groupField: 'dept', groupValue: 'Marketing', aggregatedValues: { salary: 70000 } },
-    { type: 'grand-total', depth: 0, aggregatedValues: { salary: 245000 } },
-];
-
-// --- intercept URL.createObjectURL so we can read Blob content ---
-
-let capturedBlob: Blob | null = null;
-const origCreateObjectURL = URL.createObjectURL;
-const origRevokeObjectURL = URL.revokeObjectURL;
-const origClick = HTMLAnchorElement.prototype.click;
-
-beforeEach(() => {
-    capturedBlob = null;
-    URL.createObjectURL = (blob: Blob) => { capturedBlob = blob; return 'blob:mock'; };
-    URL.revokeObjectURL = () => {};
-    HTMLAnchorElement.prototype.click = () => {};
-});
-
-afterEach(() => {
-    URL.createObjectURL = origCreateObjectURL;
-    URL.revokeObjectURL = origRevokeObjectURL;
-    HTMLAnchorElement.prototype.click = origClick;
-});
-
-// --- CSV tests ---
-
-describe('exportToCsv — flat (no groupedRows)', () => {
-    it('produces a header row followed by one row per data record', async () => {
-        exportToCsv(flatRows, columns, { fileName: 'test.csv' });
-        const text = await capturedBlob!.text();
-        const lines = text.split('\n').filter(Boolean);
-        expect(lines[0]).toBe('Department,Salary');
-        expect(lines.length).toBe(4); // header + 3 data rows
-    });
-
-    it('does not emit group-header markers or Subtotal labels', async () => {
-        exportToCsv(flatRows, columns, { fileName: 'flat.csv' });
-        const text = await capturedBlob!.text();
-        expect(text).not.toContain('dept:');
-        expect(text).not.toContain('Subtotal');
-        expect(text).not.toContain('Grand Total');
-    });
-});
-
-describe('exportToCsv — grouped', () => {
-    it('emits group-header rows, leaf rows, subtotals, and grand total', async () => {
-        exportToCsv(flatRows, columns, {
-            fileName: 'grouped.csv',
-            groupedRows,
-            aggregationModel: { salary: 'sum' },
-        });
-        const text = await capturedBlob!.text();
-        const lines = text.split('\n').filter(Boolean);
-
-        // Header
-        expect(lines[0]).toBe('Department,Salary');
-        // Group header for Engineering (depth 0 → no leading spaces, just "dept: Engineering")
-        expect(lines[1]).toContain('dept: Engineering');
-        // Leaf rows: salary values present
-        expect(lines[2]).toContain('90000');
-        expect(lines[3]).toContain('85000');
-        // Subtotal row for Engineering (formatAggregationValue adds commas: "175,000")
-        expect(lines[4]).toContain('Subtotal');
-        expect(lines[4]).toContain('175');
-        // Grand total
-        const last = lines[lines.length - 1];
-        expect(last).toContain('Grand Total');
-        expect(last).toContain('245');
-    });
-
-    it('total line count matches structure (1 header + 2 group-headers + 3 leaves + 2 subtotals + 1 grand-total)', async () => {
-        exportToCsv(flatRows, columns, { groupedRows, aggregationModel: { salary: 'sum' } });
-        const text = await capturedBlob!.text();
-        const lines = text.split('\n').filter(Boolean);
-        expect(lines.length).toBe(9);
-    });
-});
-
-// --- JSON tests ---
-
-describe('exportToJson — flat (no groupedRows)', () => {
-    it('emits a plain array with one entry per row', async () => {
-        exportToJson(flatRows, columns, {});
-        const text = await capturedBlob!.text();
-        const parsed = JSON.parse(text) as unknown[];
-        expect(Array.isArray(parsed)).toBe(true);
-        expect(parsed.length).toBe(3);
-    });
-});
-
-describe('exportToJson — grouped', () => {
-    it('emits { groups, grandTotal } with two top-level groups', async () => {
-        exportToJson(flatRows, columns, {
-            groupedRows,
-            aggregationModel: { salary: 'sum' },
-        });
-        const text = await capturedBlob!.text();
-        const parsed = JSON.parse(text) as {
-            groups: { group: string; rows: unknown[]; subtotals?: Record<string, unknown> }[];
-            grandTotal?: Record<string, unknown>;
-        };
-        expect(parsed.groups).toHaveLength(2);
-        expect(parsed.groups[0].group).toBe('dept: Engineering');
-        expect(parsed.groups[0].rows).toHaveLength(2);
-        expect(parsed.groups[0].subtotals?.salary).toBe(175000);
-        expect(parsed.groups[1].group).toBe('dept: Marketing');
-        expect(parsed.groups[1].rows).toHaveLength(1);
-        expect(parsed.grandTotal?.salary).toBe(245000);
-    });
-
-    it('falls through to flat array when groupedRows is absent', async () => {
-        exportToJson(flatRows, columns, {});
-        const text = await capturedBlob!.text();
-        const parsed = JSON.parse(text) as unknown[];
-        expect(Array.isArray(parsed)).toBe(true);
-        expect(parsed.length).toBe(3);
-    });
-});

package/lib/utils/filtering/filtering.test.ts

@@ -1,178 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { filterRows, applyFilterItem, applyQuickFilter, FILTER_OPERATORS } from './index';
-import type { GridFilterItem } from '../../types';
-
-const ROWS = [
-    { id: 1, name: 'Alice', age: 30, active: true, department: 'Engineering' },
-    { id: 2, name: 'Bob', age: 25, active: false, department: 'Marketing' },
-    { id: 3, name: 'Charlie', age: 35, active: true, department: 'Engineering' },
-    { id: 4, name: 'Diana', age: null, active: false, department: null },
-    { id: 5, name: 'Eve', age: 28, active: true, department: 'Marketing' },
-];
-
-describe('FILTER_OPERATORS', () => {
-    describe('contains', () => {
-        it('matches substring case-insensitively', () => {
-            expect(FILTER_OPERATORS.contains('Alice', 'ali')).toBe(true);
-            expect(FILTER_OPERATORS.contains('Alice', 'Bob')).toBe(false);
-        });
-        it('returns false for null values', () => {
-            expect(FILTER_OPERATORS.contains(null, 'x')).toBe(false);
-            expect(FILTER_OPERATORS.contains('x', null)).toBe(false);
-        });
-    });
-
-    describe('equals', () => {
-        it('matches case-insensitively', () => {
-            expect(FILTER_OPERATORS.equals('Alice', 'alice')).toBe(true);
-            expect(FILTER_OPERATORS.equals('Alice', 'Bob')).toBe(false);
-        });
-        it('returns true for both null', () => {
-            expect(FILTER_OPERATORS.equals(null, null)).toBe(true);
-        });
-    });
-
-    describe('startsWith / endsWith', () => {
-        it('startsWith matches prefix', () => {
-            expect(FILTER_OPERATORS.startsWith('Alice', 'Ali')).toBe(true);
-            expect(FILTER_OPERATORS.startsWith('Alice', 'ice')).toBe(false);
-        });
-        it('endsWith matches suffix', () => {
-            expect(FILTER_OPERATORS.endsWith('Alice', 'ice')).toBe(true);
-            expect(FILTER_OPERATORS.endsWith('Alice', 'Ali')).toBe(false);
-        });
-    });
-
-    describe('isEmpty / isNotEmpty', () => {
-        it('isEmpty detects null, undefined, empty string, whitespace', () => {
-            expect(FILTER_OPERATORS.isEmpty(null)).toBe(true);
-            expect(FILTER_OPERATORS.isEmpty(undefined)).toBe(true);
-            expect(FILTER_OPERATORS.isEmpty('')).toBe(true);
-            expect(FILTER_OPERATORS.isEmpty('  ')).toBe(true);
-            expect(FILTER_OPERATORS.isEmpty('x')).toBe(false);
-        });
-        it('isNotEmpty is the inverse', () => {
-            expect(FILTER_OPERATORS.isNotEmpty('x')).toBe(true);
-            expect(FILTER_OPERATORS.isNotEmpty(null)).toBe(false);
-        });
-    });
-
-    describe('numeric comparisons', () => {
-        it('> returns true when value exceeds filter', () => {
-            expect(FILTER_OPERATORS['>'](30, 25)).toBe(true);
-            expect(FILTER_OPERATORS['>'](25, 30)).toBe(false);
-        });
-        it('>= includes equality', () => {
-            expect(FILTER_OPERATORS['>='](30, 30)).toBe(true);
-        });
-        it('< and <= work symmetrically', () => {
-            expect(FILTER_OPERATORS['<'](20, 30)).toBe(true);
-            expect(FILTER_OPERATORS['<='](30, 30)).toBe(true);
-        });
-        it('returns false for non-numeric values', () => {
-            expect(FILTER_OPERATORS['>'](NaN, 10)).toBe(false);
-            expect(FILTER_OPERATORS['>'](10, NaN)).toBe(false);
-        });
-    });
-
-    describe('isAnyOf', () => {
-        it('matches any value in the array', () => {
-            expect(FILTER_OPERATORS.isAnyOf('Engineering', ['Engineering', 'Finance'])).toBe(true);
-            expect(FILTER_OPERATORS.isAnyOf('HR', ['Engineering', 'Finance'])).toBe(false);
-        });
-        it('returns false for non-array filterValue', () => {
-            expect(FILTER_OPERATORS.isAnyOf('x', null as unknown as [])).toBe(false);
-        });
-    });
-});
-
-describe('applyFilterItem', () => {
-    it('returns true for matching field/operator/value', () => {
-        const row = { id: 1, name: 'Alice', age: 30 };
-        expect(applyFilterItem(row, { field: 'name', operator: 'contains', value: 'ali' })).toBe(true);
-    });
-
-    it('returns false for non-matching', () => {
-        const row = { id: 1, name: 'Alice', age: 30 };
-        expect(applyFilterItem(row, { field: 'name', operator: 'contains', value: 'bob' })).toBe(false);
-    });
-
-    it('returns true and warns for unknown operator', () => {
-        const row = { id: 1, name: 'Alice' };
-        // Unknown operator → falls through to true (lenient)
-        expect(applyFilterItem(row, { field: 'name', operator: 'unknownOp', value: 'x' } as unknown as GridFilterItem)).toBe(true);
-    });
-});
-
-describe('applyQuickFilter', () => {
-    it('returns true when empty quickFilterValues', () => {
-        expect(applyQuickFilter({ id: 1, name: 'Alice' }, [])).toBe(true);
-    });
-    it('matches all terms (AND logic)', () => {
-        const row = { id: 1, name: 'Alice', department: 'Engineering' };
-        expect(applyQuickFilter(row, ['alice', 'eng'])).toBe(true);
-        expect(applyQuickFilter(row, ['alice', 'marketing'])).toBe(false);
-    });
-    it('ignores null field values', () => {
-        expect(applyQuickFilter({ id: 1, name: null }, ['x'])).toBe(false);
-    });
-});
-
-describe('filterRows', () => {
-    it('returns all rows when filterModel is empty', () => {
-        const result = filterRows(ROWS, { items: [] });
-        expect(result).toHaveLength(ROWS.length);
-    });
-
-    it('filters by single contains item', () => {
-        const result = filterRows(ROWS, {
-            items: [{ field: 'name', operator: 'contains', value: 'a' }],
-        });
-        // Alice, Charlie, Diana
-        expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['Alice', 'Charlie', 'Diana']));
-        expect(result).toHaveLength(3);
-    });
-
-    it('applies AND logic across multiple items', () => {
-        const result = filterRows(ROWS, {
-            items: [
-                { field: 'department', operator: 'equals', value: 'Engineering' },
-                { field: 'age', operator: '>', value: 30 },
-            ],
-            logicOperator: 'and',
-        });
-        expect(result.map(r => r.name)).toEqual(['Charlie']);
-    });
-
-    it('applies OR logic across multiple items', () => {
-        const result = filterRows(ROWS, {
-            items: [
-                { field: 'name', operator: 'equals', value: 'Alice' },
-                { field: 'name', operator: 'equals', value: 'Eve' },
-            ],
-            logicOperator: 'or',
-        });
-        expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['Alice', 'Eve']));
-        expect(result).toHaveLength(2);
-    });
-
-    it('applies quickFilterValues (global search)', () => {
-        const result = filterRows(ROWS, {
-            items: [],
-            quickFilterValues: ['engineering'],
-        });
-        expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['Alice', 'Charlie']));
-    });
-
-    it('handles null field values without throwing', () => {
-        const result = filterRows(ROWS, {
-            items: [{ field: 'department', operator: 'isEmpty' }],
-        });
-        expect(result.map(r => r.name)).toEqual(['Diana']);
-    });
-
-    it('returns same reference when no filter items and no quickfilter', () => {
-        const result = filterRows(ROWS, { items: [], quickFilterValues: [] });
-        expect(result).toBe(ROWS);
-    });
-});

package/lib/utils/sorting/sorting.test.ts

@@ -1,88 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { sortRows, compareValues } from './index';
-
-describe('compareValues', () => {
-    describe('null handling', () => {
-        it('null === null → 0', () => expect(compareValues(null, null, 'asc')).toBe(0));
-        it('null sorts last in asc', () => expect(compareValues(null, 1, 'asc')).toBeGreaterThan(0));
-        it('null sorts first in desc', () => expect(compareValues(null, 1, 'desc')).toBeLessThan(0));
-        it('non-null before null in asc', () => expect(compareValues(1, null, 'asc')).toBeLessThan(0));
-    });
-
-    describe('numbers', () => {
-        it('asc: smaller first', () => expect(compareValues(1, 2, 'asc')).toBeLessThan(0));
-        it('desc: larger first', () => expect(compareValues(2, 1, 'desc')).toBeLessThan(0));
-        it('equal numbers → 0', () => expect(compareValues(5, 5, 'asc')).toBe(0));
-    });
-
-    describe('dates', () => {
-        const d1 = new Date('2023-01-01');
-        const d2 = new Date('2024-01-01');
-        it('asc: earlier date first', () => expect(compareValues(d1, d2, 'asc')).toBeLessThan(0));
-        it('desc: later date first', () => expect(compareValues(d2, d1, 'desc')).toBeLessThan(0));
-    });
-
-    describe('strings', () => {
-        it('asc: lexicographic order', () => expect(compareValues('apple', 'banana', 'asc')).toBeLessThan(0));
-        it('desc: reversed order', () => expect(compareValues('banana', 'apple', 'desc')).toBeLessThan(0));
-        it('case-insensitive', () => expect(compareValues('APPLE', 'apple', 'asc')).toBe(0));
-    });
-});
-
-describe('sortRows', () => {
-    const ROWS = [
-        { id: 3, name: 'Charlie', age: 35, dept: 'Engineering' },
-        { id: 1, name: 'Alice', age: 30, dept: 'Marketing' },
-        { id: 4, name: 'Diana', age: 25, dept: 'Engineering' },
-        { id: 2, name: 'Bob', age: 30, dept: 'Marketing' },
-    ];
-
-    it('returns same reference when sortModel is empty', () => {
-        const result = sortRows(ROWS, []);
-        expect(result).toBe(ROWS);
-    });
-
-    it('does not mutate the original array', () => {
-        const original = [...ROWS];
-        sortRows(ROWS, [{ field: 'name', sort: 'asc' }]);
-        expect(ROWS).toEqual(original);
-    });
-
-    it('sorts by single field asc', () => {
-        const result = sortRows(ROWS, [{ field: 'name', sort: 'asc' }]);
-        expect(result.map(r => r.name)).toEqual(['Alice', 'Bob', 'Charlie', 'Diana']);
-    });
-
-    it('sorts by single field desc', () => {
-        const result = sortRows(ROWS, [{ field: 'age', sort: 'desc' }]);
-        expect(result.map(r => r.age)).toEqual([35, 30, 30, 25]);
-    });
-
-    it('applies multi-field sort (age asc, name asc for ties)', () => {
-        const result = sortRows(ROWS, [
-            { field: 'age', sort: 'asc' },
-            { field: 'name', sort: 'asc' },
-        ]);
-        expect(result.map(r => r.name)).toEqual(['Diana', 'Alice', 'Bob', 'Charlie']);
-    });
-
-    it('handles null values — nulls sort last in asc', () => {
-        const rowsWithNull = [
-            { id: 1, name: 'Alice', age: 30 },
-            { id: 2, name: null, age: 25 },
-            { id: 3, name: 'Bob', age: 35 },
-        ];
-        const result = sortRows(rowsWithNull, [{ field: 'name', sort: 'asc' }]);
-        expect(result[result.length - 1].name).toBeNull();
-    });
-
-    it('handles rows with identical values — stable relative order preserved', () => {
-        const rows = [
-            { id: 1, score: 10 },
-            { id: 2, score: 10 },
-            { id: 3, score: 10 },
-        ];
-        const result = sortRows(rows, [{ field: 'score', sort: 'asc' }]);
-        expect(result.map(r => r.id)).toEqual([1, 2, 3]);
-    });
-});