@opencorestack/opengridx 0.1.8 → 0.1.9

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);
+    });
+});

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencorestack/opengridx",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "OpenGridX: High-performance React data infrastructure. Unlock advanced Row Grouping, Excel Export, and Column Pinning without the usual \"Pro\" gatekeeping. Built for speed, scale, and complete architectural freedom. Fully open, virtualization-ready, and feature-complete.",
   "type": "module",
   "main": "./dist/opengridx.umd.js",
@@ -41,6 +41,9 @@
     "build:lib": "tsc --project tsconfig.build.json && vite build --config vite.config.lib.js && cp lib/styles/opengridx.css.d.ts dist/opengridx.css.d.ts",
     "lint": "eslint .",
     "preview": "vite preview",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage",
     "prepublishOnly": "npm run build:lib"
   },
   "keywords": [
@@ -85,6 +88,9 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",
+    "@testing-library/jest-dom": "^7.0.0",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
     "@types/node": "^25.0.8",
     "@types/react": "^19.2.5",
     "@types/react-dom": "^19.2.3",
@@ -94,13 +100,14 @@
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-refresh": "^0.4.24",
     "globals": "^16.5.0",
+    "jsdom": "^29.1.1",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
+    "react-router-dom": "^7.13.1",
     "typescript": "^5.9.3",
+    "typescript-eslint": "^8.65.0",
     "vite": "^7.2.4",
     "vite-plugin-dts": "^4.5.4",
-    "vitest": "^4.0.18",
-    "react-router-dom": "^7.13.1"
-  },
-  "dependencies": {}
+    "vitest": "^4.0.18"
+  }
 }

package/lib/utils/virtualization/index.ts

@@ -1,106 +0,0 @@
-
-import { GridRenderContext } from '../../types';
-
-export interface VirtualizationParams {
-  scrollTop: number;
-  scrollLeft: number;
-  viewportHeight: number;
-  viewportWidth: number;
-  rowHeight: number;
-  totalRows: number;
-  columnWidths: number[];
-  overscan?: number;
-}
-
-export interface VirtualizationResult {
-  renderContext: GridRenderContext;
-  offsetTop: number;
-  offsetLeft: number;
-  totalHeight: number;
-  totalWidth: number;
-}
-
-export function calculateVirtualization(params: VirtualizationParams): VirtualizationResult {
-  const {
-    scrollTop,
-    scrollLeft,
-    viewportHeight,
-    viewportWidth,
-    rowHeight,
-    totalRows,
-    columnWidths,
-    overscan = 3
-  } = params;
-
-  const firstVisibleRow = Math.floor(scrollTop / rowHeight);
-  const lastVisibleRow = Math.min(
-    totalRows - 1,
-    Math.ceil((scrollTop + viewportHeight) / rowHeight)
-  );
-
-  const firstRowIndex = Math.max(0, firstVisibleRow - overscan);
-  const lastRowIndex = Math.min(totalRows - 1, lastVisibleRow + overscan);
-
-  let accumulatedWidth = 0;
-  let firstColumnIndex = 0;
-  let lastColumnIndex = columnWidths.length - 1;
-  let offsetLeft = 0;
-
-  for (let i = 0; i < columnWidths.length; i++) {
-    if (accumulatedWidth + columnWidths[i] > scrollLeft) {
-      firstColumnIndex = Math.max(0, i - overscan);
-      break;
-    }
-    accumulatedWidth += columnWidths[i];
-  }
-
-  offsetLeft = columnWidths.slice(0, firstColumnIndex).reduce((sum, width) => sum + width, 0);
-
-  accumulatedWidth = offsetLeft;
-  for (let i = firstColumnIndex; i < columnWidths.length; i++) {
-    accumulatedWidth += columnWidths[i];
-    if (accumulatedWidth >= scrollLeft + viewportWidth) {
-      lastColumnIndex = Math.min(columnWidths.length - 1, i + overscan);
-      break;
-    }
-  }
-
-  const totalHeight = totalRows * rowHeight;
-  const totalWidth = columnWidths.reduce((sum, width) => sum + width, 0);
-  const offsetTop = firstRowIndex * rowHeight;
-
-  return {
-    renderContext: {
-      firstRowIndex,
-      lastRowIndex,
-      firstColumnIndex,
-      lastColumnIndex
-    },
-    offsetTop,
-    offsetLeft,
-    totalHeight,
-    totalWidth
-  };
-}
-
-export function getRowPosition(rowIndex: number, rowHeight: number): number {
-  return rowIndex * rowHeight;
-}
-
-export function getColumnPosition(colIndex: number, columnWidths: number[]): number {
-  return columnWidths.slice(0, colIndex).reduce((sum, width) => sum + width, 0);
-}
-
-export function isRowVisible(
-  rowIndex: number,
-  renderContext: GridRenderContext
-): boolean {
-  return rowIndex >= renderContext.firstRowIndex && rowIndex <= renderContext.lastRowIndex;
-}
-
-export function isColumnVisible(
-  colIndex: number,
-  renderContext: GridRenderContext
-): boolean {
-  return colIndex >= renderContext.firstColumnIndex && colIndex <= renderContext.lastColumnIndex;
-}