@opencorestack/opengridx 0.1.8 → 1.0.0

package/lib/types/index.ts

@@ -7,8 +7,24 @@ export type GridRowId = string | number;
 export interface GridRowModel {
   /** Uniquely identifies the row. */
   id: GridRowId;
+  /** Internal: row has child nodes (tree data / row grouping). */
+  _hasChildren?: boolean;
+  /** Internal: row is a skeleton placeholder during infinite-scroll loading. */
+  _isSkeleton?: boolean;
+  /** Internal: depth in the tree or grouping hierarchy. */
+  _treeDepth?: number;
+  /** Internal: whether the group/tree node is currently expanded. */
+  _isExpanded?: boolean;
+  /** Internal: field used for grouping at this level. */
+  _groupingField?: string;
+  /** Internal: grouping field value at this level. */
+  _groupingValue?: unknown;
+  /** Internal: total descendant count for tree/grouping nodes. */
+  _descendantCount?: number;
+  /** Internal: server-reported child count for lazy-loaded tree nodes. */
+  serverChildrenCount?: number;
   /** Any other dynamic row properties. */
-  [key: string]: any;
+  [key: string]: unknown;
 }
 
 export type GridAlignment = 'left' | 'center' | 'right';
@@ -27,10 +43,10 @@ export interface GridTreeNode {
     /** The field this node is grouping by. */
     groupingField?: string;
     /** The actual value being grouped. */
-    groupingValue?: any;
+    groupingValue?: unknown;
 
     /** Computed aggregation results for this group. */
-    aggregatedValues?: Record<string, any>;
+    aggregatedValues?: Record<string, unknown>;
     /** Position of the aggregation row relative to the group. */
     aggregationPosition?: 'inline' | 'footer' | null; 
     /** Current expansion state. */
@@ -91,13 +107,15 @@ export interface GridColDef<R extends GridRowModel = GridRowModel> {
   hideable?: boolean;
   /** If false, the column cannot be pinned. */
   pinnable?: boolean;
+  /** Internal: marks this column as a virtual spacer used for horizontal virtualization. */
+  isSpacer?: boolean;
   /** Type used to determine default operators and formatting logic. */
   type?: 'string' | 'number' | 'date' | 'boolean' | 'singleSelect' | 'image';
   /** Options used for 'singleSelect' type. */
-  valueOptions?: Array<string | number | { value: any; label: string }>;
+  valueOptions?: Array<string | number | { value: unknown; label: string }>;
 
   /** Function to compute a cell value from raw row data. */
-  valueGetter?: (params: GridValueGetterParams<R>) => any;
+  valueGetter?: (params: GridValueGetterParams<R>) => unknown;
   /** Function to format a value into a human-readable string. */
   valueFormatter?: (params: GridValueFormatterParams<R>) => string;
   /** Custom component or element to render in the cell. */
@@ -186,13 +204,13 @@ export interface GridValueGetterParams<R extends GridRowModel = GridRowModel> {
   /** The field name. */
   field: string;
   /** The raw value from the row object. */
-  value: any;
+  value: unknown;
 }
 
 /** Parameters passed to the `valueFormatter` function. */
 export interface GridValueFormatterParams<R extends GridRowModel = GridRowModel> {
   /** The raw value to format. */
-  value: any;
+  value: unknown;
   /** The row object. */
   row: R;
   /** The field name. */
@@ -202,7 +220,7 @@ export interface GridValueFormatterParams<R extends GridRowModel = GridRowModel>
 /** Parameters passed to the `renderCell` function. */
 export interface GridRenderCellParams<R extends GridRowModel = GridRowModel> {
   /** The current cell value. */
-  value: any;
+  value: unknown;
   /** The row object. */
   row: R;
   /** The field name and unique ID. */
@@ -256,7 +274,7 @@ export interface GridFilterItem {
   /** The comparison operator. */
   operator: GridFilterOperator;
   /** The value to compare against. */
-  value?: any;
+  value?: unknown;
 }
 
 /** Describes a group of filters combined with a logical operator. */
@@ -325,7 +343,7 @@ export interface GridGetRowsParams {
 export interface GridGetRowsResponse<R extends GridRowModel = GridRowModel> {
   rows: R[];
   rowCount?: number;
-    aggregationResults?: Record<string, any>;
+    aggregationResults?: Record<string, unknown>;
 }
 
 /**
@@ -341,7 +359,7 @@ export interface GridDataSource<R extends GridRowModel = GridRowModel> {
   /**
    * Optional: Fetches aggregation results for the entire dataset.
    */
-  getAggregations?: (params: Omit<GridGetRowsParams, 'startRow' | 'endRow'>) => Promise<Record<string, any>>;
+  getAggregations?: (params: Omit<GridGetRowsParams, 'startRow' | 'endRow'>) => Promise<Record<string, unknown>>;
 }
 
 export interface GridPaginationModel {
@@ -363,19 +381,17 @@ export interface GridPinnedRows<R extends GridRowModel = GridRowModel> {
 
 export interface GridVirtualizationState {
   renderContext: GridRenderContext;
-  scrollTop: number;
-  scrollLeft: number;
 }
 
 export type GridRowGroupingModel = string[]; 
 
-export type GridAggregationFunction = (values: any[]) => any;
+export type GridAggregationFunction = (values: unknown[]) => unknown;
 
 export interface GridAggregationModel {
-  [field: string]: string; 
+  [field: string]: string;
 }
 
-export type GridAggregationResult = Record<string, any>;
+export type GridAggregationResult = Record<string, unknown>;
 
 export type GridAggregationPosition = 'footer' | 'inline' | 'both';
 
@@ -400,7 +416,7 @@ export interface GridRenderContext {
   lastColumnIndex: number;
 }
 
-export interface GridState {
+export interface GridInternalState {
   rows: {
     idRowsLookup: Map<GridRowId, GridRowModel>;
     allRows: GridRowId[];
@@ -437,7 +453,7 @@ export interface GridState {
   };
   dataSource: {
     loading: boolean;
-    error: any;
+    error: unknown;
   };
 }
 
@@ -603,7 +619,7 @@ export interface DataGridProps<R extends GridRowModel = GridRowModel> {
   /** Callback to process an updated row after inline editing. Supports promises and validation. */
   processRowUpdate?: (newRow: R, oldRow: R) => R | Promise<R>;
   /** Callback fired if `processRowUpdate` throws or rejects. */
-  onProcessRowUpdateError?: (error: any) => void;
+  onProcessRowUpdateError?: (error: unknown) => void;
 
   /** Interface for connecting the grid to an external (server-side) data source. */
   dataSource?: GridDataSource<R>;
@@ -616,23 +632,23 @@ export interface DataGridProps<R extends GridRowModel = GridRowModel> {
   /** Custom components to replace internal grid parts. */
   slots?: {
     /** Component rendered as the grid toolbar. */
-    toolbar?: React.ComponentType<any>;
+    toolbar?: React.ComponentType<Record<string, unknown>>;
     /** Component rendered as the pagination control. */
-    pagination?: React.ComponentType<any>;
+    pagination?: React.ComponentType<Record<string, unknown>>;
     /** Component rendered when the grid is empty. */
-    noRowsOverlay?: React.ComponentType<any>;
+    noRowsOverlay?: React.ComponentType<Record<string, unknown>>;
     /** Component rendered during loading states. */
-    loadingOverlay?: React.ComponentType<any>;
+    loadingOverlay?: React.ComponentType<Record<string, unknown>>;
     /** Component rendered at the very bottom of the grid. */
-    footer?: React.ComponentType<any>;
+    footer?: React.ComponentType<Record<string, unknown>>;
   };
   /** Properties passed directly to custom slots. */
   slotProps?: {
-    toolbar?: any;
-    pagination?: any;
-    noRowsOverlay?: any;
-    loadingOverlay?: any;
-    footer?: any;
+    toolbar?: Record<string, unknown>;
+    pagination?: Record<string, unknown>;
+    noRowsOverlay?: Record<string, unknown>;
+    loadingOverlay?: Record<string, unknown>;
+    footer?: Record<string, unknown>;
   };
 
   /** When true, renders the grid as a single-column list of cards. Perfect for mobile/responsive views. */
@@ -647,7 +663,7 @@ export interface DataGridProps<R extends GridRowModel = GridRowModel> {
   columnGroupingModel?: GridColumnGroupingModel;
 }
 
-export interface GridEditCellProps<V = any> {
+export interface GridEditCellProps<V = unknown> {
   id: GridRowId;
   field: string;
   value?: V;
@@ -669,7 +685,7 @@ export interface GridRowParams<R extends GridRowModel = GridRowModel> {
 export interface GridCellParams<R extends GridRowModel = GridRowModel> {
   row: R;
   field: string;
-  value: any;
+  value: unknown;
   colDef: GridColDef<R>;
   rowIndex: number;
   colIndex: number;
@@ -707,7 +723,7 @@ export interface GridApi {
   /** Returns all rows currently visible after filtering and sorting. */
   getVisibleRows: () => GridRowModel[];
   /** Returns the current aggregation results. */
-  getAggregationResult: () => Record<string, any> | null;
+  getAggregationResult: () => Record<string, unknown> | null;
   /** Returns the active aggregation configuration. */
   getAggregationModel: () => GridAggregationModel | null;
 

package/lib/utils/export/exportToExcelAdvanced.ts

@@ -63,7 +63,7 @@ export interface ExcelAdvancedExportOptions {
     /** Body font size (default: 10) */
     bodyFontSize?: number;
     /** Current aggregation result */
-    aggregationResult?: Record<string, any> | null;
+    aggregationResult?: Record<string, unknown> | null;
     /** Current aggregation model */
     aggregationModel?: GridAggregationModel | null;
     /** Currently selected row IDs */
@@ -72,7 +72,7 @@ export interface ExcelAdvancedExportOptions {
 
 // ─── Cell type inference ──────────────────────────────────────────────────────
 
-function inferCellType(colDef: GridColDef<any>, value: any): 'number' | 'boolean' | 'date' | 'string' {
+function inferCellType(colDef: GridColDef<GridRowModel>, value: unknown): 'number' | 'boolean' | 'date' | 'string' {
     if (colDef.type === 'number') return 'number';
     if (colDef.type === 'boolean') return 'boolean';
     if (colDef.type === 'date') return 'date';
@@ -84,7 +84,7 @@ function inferCellType(colDef: GridColDef<any>, value: any): 'number' | 'boolean
 
 // ─── Default numFmt per column type ──────────────────────────────────────────
 
-function defaultNumFmt(colDef: GridColDef<any>): string | undefined {
+function defaultNumFmt(colDef: GridColDef<GridRowModel>): string | undefined {
     if (colDef.type === 'number') return '#,##0.##';
     if (colDef.type === 'date') return 'yyyy-mm-dd';
     return undefined;
@@ -92,7 +92,7 @@ function defaultNumFmt(colDef: GridColDef<any>): string | undefined {
 
 // ─── Column display width (chars) ────────────────────────────────────────────
 
-function colWidth(colDef: GridColDef<any>, override?: number): number {
+function colWidth(colDef: GridColDef<GridRowModel>, override?: number): number {
     if (override != null) return override;
     const px = (colDef.width ?? 120) as number;
     return Math.min(60, Math.max(8, (px - 5) / 7));
@@ -195,18 +195,18 @@ export async function exportToExcelAdvanced<R extends GridRowModel>(
     workbook.creator = 'OpenGridX';
     workbook.created = new Date();
 
-    // Filter system columns — cast to GridColDef<any> to avoid generic covariance issues
-    const exportColumns: GridColDef<any>[] = (columns as GridColDef<any>[]).filter(col =>
+    // Filter system columns
+    const exportColumns: GridColDef<GridRowModel>[] = (columns as unknown as GridColDef<GridRowModel>[]).filter(col =>
         col.exportable !== false &&
         col.field !== '__check__' &&
         col.field !== '__actions__' &&
-        !(col as any).isSpacer
+        !col.isSpacer
     );
 
-    const allRows: any[] = rows as any[];
-    const sRows: any[] = (selectedRows && selectedRows.length > 0
+    const allRows: GridRowModel[] = rows as GridRowModel[];
+    const sRows: GridRowModel[] = (selectedRows && selectedRows.length > 0
         ? rows.filter(r => selectedRows.includes(r.id))
-        : rows) as any[];
+        : rows) as GridRowModel[];
 
     // Normalise sheet definitions
     const resolvedSheets: (ExcelSheetDefinition | { type: 'summary'; name?: string })[] =
@@ -279,7 +279,7 @@ export async function exportToExcelAdvanced<R extends GridRowModel>(
             const seen = new Set<string>();
             rowsToExport.forEach(row => {
                 imageColumns.forEach(col => {
-                    const val = (row as any)[col.field];
+                    const val = row[col.field];
                     if (typeof val === 'string' && val && !imageCache.has(val) && !seen.has(val)) {
                         urlsNeeded.push(val);
                         seen.add(val);
@@ -348,7 +348,7 @@ export async function exportToExcelAdvanced<R extends GridRowModel>(
                 // Image columns: write empty string; image placed below
                 if (columnStyles[col.field]?.embedImage) return '';
 
-                let value: any = (row as any)[col.field];
+                let value: unknown = row[col.field];
                 if (col.valueGetter) {
                     value = col.valueGetter({ row, field: col.field, value });
                 }
@@ -399,7 +399,7 @@ export async function exportToExcelAdvanced<R extends GridRowModel>(
 
                 imageColumns.forEach(col => {
                     const colIdx = exportColumns.indexOf(col);
-                    const url    = (row as any)[col.field];
+                    const url    = row[col.field];
                     const imgId  = typeof url === 'string' ? imageCache.get(url) : undefined;
 
                     if (imgId === undefined) {
@@ -433,7 +433,7 @@ export async function exportToExcelAdvanced<R extends GridRowModel>(
                         },
                         ext: { width: imgW, height: imgH },
                         editAs: 'oneCell',
-                    } as any);
+                    } as unknown as import('exceljs').ImageRange);
                 });
             } else {
                 dataRow.height = 16;

package/lib/utils/export/index.ts

@@ -7,7 +7,7 @@ export interface CsvExportOptions {
     includeHeaders?: boolean;
     delimiter?: string;
     selectedRows?: (string | number)[];
-    aggregationResult?: Record<string, any> | null;
+    aggregationResult?: Record<string, unknown> | null;
     aggregationModel?: GridAggregationModel | null;
 }
 
@@ -48,7 +48,7 @@ export function exportToCsv<R extends GridRowModel>(
 
     rowsToExport.forEach(row => {
         const values = exportColumns.map(col => {
-            let value: any = row[col.field as keyof R];
+            let value: unknown = (row as GridRowModel)[col.field];
 
             if (col.valueGetter) {
                 value = col.valueGetter({ row, field: col.field, value });
@@ -109,7 +109,7 @@ export interface ExcelExportOptions {
     sheetName?: string;
     includeHeaders?: boolean;
     selectedRows?: (string | number)[];
-    aggregationResult?: Record<string, any> | null;
+    aggregationResult?: Record<string, unknown> | null;
     aggregationModel?: GridAggregationModel | null;
 }
 
@@ -119,7 +119,7 @@ export function exportToExcel<R extends GridRowModel>(
     options: ExcelExportOptions = {}
 ): void {
     const {
-        fileName = 'export.xlsx',
+        fileName = 'export.xls',
         sheetName = 'Sheet1',
         includeHeaders = true,
         selectedRows
@@ -159,7 +159,7 @@ export function exportToExcel<R extends GridRowModel>(
     rowsToExport.forEach(row => {
         html += '<tr>';
         exportColumns.forEach(col => {
-            let value: any = row[col.field as keyof R];
+            let value: unknown = (row as GridRowModel)[col.field];
 
             if (col.valueGetter) {
                 value = col.valueGetter({ row, field: col.field, value });
@@ -227,7 +227,7 @@ export interface JsonExportOptions {
     fileName?: string;
     pretty?: boolean;
     selectedRows?: (string | number)[];
-    aggregationResult?: Record<string, any> | null;
+    aggregationResult?: Record<string, unknown> | null;
     aggregationModel?: GridAggregationModel | null;
 }
 
@@ -264,9 +264,9 @@ export function exportToJson<R extends GridRowModel>(
 
     // Build JSON data
     const data = rowsToExport.map(row => {
-        const obj: any = {};
+        const obj: Record<string, unknown> = {};
         exportColumns.forEach(col => {
-            let value: any = row[col.field as keyof R];
+            let value: unknown = (row as GridRowModel)[col.field];
 
             // Use valueGetter if available
             if (col.valueGetter) {
@@ -278,23 +278,27 @@ export function exportToJson<R extends GridRowModel>(
         return obj;
     });
 
-    let outData: any = data;
+    type ExportJsonPayload =
+        | Record<string, unknown>[]
+        | { data: Record<string, unknown>[]; aggregation: { labels: Record<string, unknown>; values: Record<string, unknown> } };
+
+    let outData: ExportJsonPayload = data;
 
     if (options.aggregationResult) {
         const aggResult = options.aggregationResult;
         const aggModel = options.aggregationModel || {};
-        
-        const summaryLabelObj: any = {};
+
+        const summaryLabelObj: Record<string, unknown> = {};
         exportColumns.forEach((col) => {
             if (aggModel[col.field]) {
                summaryLabelObj[col.field] = aggModel[col.field].toUpperCase();
             }
         });
 
-        const summaryDataObj: any = {};
+        const summaryDataObj: Record<string, unknown> = {};
         exportColumns.forEach((col) => {
             if (aggResult[col.field] !== undefined && aggResult[col.field] !== null) {
-               let aggVal = aggResult[col.field];
+               let aggVal: unknown = aggResult[col.field];
                if (col.valueFormatter) {
                    aggVal = col.valueFormatter({ value: aggVal, row: {} as R, field: col.field });
                } else if (aggModel[col.field]) {
@@ -326,7 +330,7 @@ export function exportToJson<R extends GridRowModel>(
 export interface PrintOptions {
     title?: string;
     selectedRows?: (string | number)[];
-    aggregationResult?: Record<string, any> | null;
+    aggregationResult?: Record<string, unknown> | null;
     aggregationModel?: GridAggregationModel | null;
 }
 
@@ -376,7 +380,7 @@ export async function printGrid<R extends GridRowModel>(
     try {
         let title = 'Print';
         let selectedRows: (string | number)[] | undefined;
-        let aggregationResult: Record<string, any> | null = null;
+        let aggregationResult: Record<string, unknown> | null = null;
         let aggregationModel: GridAggregationModel | null = null;
 
         if (typeof titleOrOptions === 'string') {
@@ -447,7 +451,7 @@ export async function printGrid<R extends GridRowModel>(
         rowsToExport.forEach(row => {
             html += '<tr>';
             exportColumns.forEach(col => {
-                let value: any = row[col.field as keyof R];
+                let value: unknown = (row as GridRowModel)[col.field];
 
                 if (col.valueGetter) {
                     value = col.valueGetter({ row, field: col.field, value });
@@ -529,10 +533,11 @@ export async function printGrid<R extends GridRowModel>(
             }
         }, 500);
 
-    } catch (e: any) {
+    } catch (e) {
         console.error('Print generation failed:', e);
         if (printWindow && !printWindow.closed) {
-            printWindow.document.body.innerHTML = `<div style="color: red; padding: 20px;"><h3>Error Generating Print Preview</h3><p>${e.message}</p></div>`;
+            const message = e instanceof Error ? e.message : String(e);
+            printWindow.document.body.innerHTML = `<div style="color: red; padding: 20px;"><h3>Error Generating Print Preview</h3><p>${message}</p></div>`;
         }
     }
 }

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

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