@opencorestack/opengridx 0.1.8 → 1.0.0

package/lib/utils/filtering/index.ts

@@ -2,36 +2,36 @@
 import type { GridRowModel, GridFilterItem, GridFilterModel, GridFilterGroup } from '../../types';
 
 export const FILTER_OPERATORS = {
-  contains: (value: any, filterValue: any): boolean => {
+  contains: (value: unknown, filterValue: unknown): boolean => {
     if (value == null || filterValue == null) return false;
     return String(value).toLowerCase().includes(String(filterValue).toLowerCase());
   },
 
-  equals: (value: any, filterValue: any): boolean => {
+  equals: (value: unknown, filterValue: unknown): boolean => {
     if (value == null && filterValue == null) return true;
     if (value == null || filterValue == null) return false;
     return String(value).toLowerCase() === String(filterValue).toLowerCase();
   },
 
-  startsWith: (value: any, filterValue: any): boolean => {
+  startsWith: (value: unknown, filterValue: unknown): boolean => {
     if (value == null || filterValue == null) return false;
     return String(value).toLowerCase().startsWith(String(filterValue).toLowerCase());
   },
 
-  endsWith: (value: any, filterValue: any): boolean => {
+  endsWith: (value: unknown, filterValue: unknown): boolean => {
     if (value == null || filterValue == null) return false;
     return String(value).toLowerCase().endsWith(String(filterValue).toLowerCase());
   },
 
-  isEmpty: (value: any): boolean => {
+  isEmpty: (value: unknown): boolean => {
     return value == null || String(value).trim() === '';
   },
 
-  isNotEmpty: (value: any): boolean => {
+  isNotEmpty: (value: unknown): boolean => {
     return value != null && String(value).trim() !== '';
   },
 
-  '>': (value: any, filterValue: any): boolean => {
+  '>': (value: unknown, filterValue: unknown): boolean => {
     if (value == null || filterValue == null) return false;
     const numValue = Number(value);
     const numFilter = Number(filterValue);
@@ -39,7 +39,7 @@ export const FILTER_OPERATORS = {
     return numValue > numFilter;
   },
 
-  '>=': (value: any, filterValue: any): boolean => {
+  '>=': (value: unknown, filterValue: unknown): boolean => {
     if (value == null || filterValue == null) return false;
     const numValue = Number(value);
     const numFilter = Number(filterValue);
@@ -47,7 +47,7 @@ export const FILTER_OPERATORS = {
     return numValue >= numFilter;
   },
 
-  '<': (value: any, filterValue: any): boolean => {
+  '<': (value: unknown, filterValue: unknown): boolean => {
     if (value == null || filterValue == null) return false;
     const numValue = Number(value);
     const numFilter = Number(filterValue);
@@ -55,7 +55,7 @@ export const FILTER_OPERATORS = {
     return numValue < numFilter;
   },
 
-  '<=': (value: any, filterValue: any): boolean => {
+  '<=': (value: unknown, filterValue: unknown): boolean => {
     if (value == null || filterValue == null) return false;
     const numValue = Number(value);
     const numFilter = Number(filterValue);
@@ -63,7 +63,7 @@ export const FILTER_OPERATORS = {
     return numValue <= numFilter;
   },
 
-  '!=': (value: any, filterValue: any): boolean => {
+  '!=': (value: unknown, filterValue: unknown): boolean => {
     if (filterValue == null || filterValue === '') return true;
     // Numeric comparison if both are numbers, otherwise string
     const numV = Number(value);
@@ -72,28 +72,28 @@ export const FILTER_OPERATORS = {
     return String(value).toLowerCase() !== String(filterValue).toLowerCase();
   },
 
-  isAnyOf: (value: any, filterValue: any[]): boolean => {
+  isAnyOf: (value: unknown, filterValue: unknown[]): boolean => {
     if (value == null || !Array.isArray(filterValue)) return false;
-    return filterValue.some(v => 
+    return filterValue.some(v =>
       String(value).toLowerCase() === String(v).toLowerCase()
     );
   },
 
-  not: (value: any, filterValue: any): boolean => {
+  not: (value: unknown, filterValue: unknown): boolean => {
       if (value == null && filterValue == null) return false;
       if (value == null || filterValue == null) return true;
       return String(value).toLowerCase() !== String(filterValue).toLowerCase();
   },
 
   // Used by boolean and singleSelect — case-insensitive string comparison
-  is: (value: any, filterValue: any): boolean => {
+  is: (value: unknown, filterValue: unknown): boolean => {
       if (filterValue == null || filterValue === '') return true;
       const rowStr = String(value).toLowerCase();
       const filterStr = String(filterValue).toLowerCase();
       return rowStr === filterStr;
   },
 
-  '=': (value: any, filterValue: any): boolean => {
+  '=': (value: unknown, filterValue: unknown): boolean => {
       if (value == null || filterValue == null || filterValue === '') return false;
       return Number(value) === Number(filterValue);
   },
@@ -119,7 +119,7 @@ export function applyFilterItem<R extends GridRowModel>(
   }
 
   // Apply the operator
-  return operatorFn(rowValue, value);
+  return (operatorFn as (a: unknown, b: unknown) => boolean)(rowValue, value);
 }
 
 /**
@@ -155,9 +155,9 @@ export function isRowMatchingFilter<R extends GridRowModel>(
 ): boolean {
   // Normalize input: GridFilterModel matches GridFilterGroup shape largely, but let's be safe
 
-  const items = (filterModel as any).items || [];
-  const logicOperator = (filterModel as any).logicOperator || 'and';
-  const quickFilterValues = (filterModel as any).quickFilterValues || [];
+  const items = filterModel.items ?? [];
+  const logicOperator = filterModel.logicOperator ?? 'and';
+  const quickFilterValues = ('quickFilterValues' in filterModel ? filterModel.quickFilterValues : undefined) ?? [];
 
   if (quickFilterValues.length > 0 && !applyQuickFilter(row, quickFilterValues)) {
     return false;

package/lib/utils/sorting/index.ts

@@ -1,7 +1,7 @@
 
 import type { GridRowModel, GridSortItem } from '../../types';
 
-export function compareValues(a: any, b: any, direction: 'asc' | 'desc'): number {
+export function compareValues(a: unknown, b: unknown, direction: 'asc' | 'desc'): number {
 
   if (a == null && b == null) return 0;
   if (a == null) return direction === 'asc' ? 1 : -1;

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": "1.0.0",
   "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;
-}