argent-grid 0.1.0 → 0.2.0

package/src/lib/rendering/utils/damage-tracker.ts

@@ -86,10 +86,7 @@ export class DamageTracker {
   /**
    * Mark dirty based on selection change
    */
-  markSelectionChanged(
-    oldSelection: Set<number>,
-    newSelection: Set<number>
-  ): void {
+  markSelectionChanged(oldSelection: Set<number>, newSelection: Set<number>): void {
     // Mark rows that changed selection state
     for (const row of oldSelection) {
       if (!newSelection.has(row)) {
@@ -186,7 +183,7 @@ export class DamageTracker {
    * Get dirty cells
    */
   getDirtyCells(): Array<[number, number]> {
-    return Array.from(this.damagedCells).map(key => {
+    return Array.from(this.damagedCells).map((key) => {
       const [col, row] = key.split(',').map(Number);
       return [col, row];
     });
@@ -201,16 +198,8 @@ export class DamageTracker {
    * - If too many individual cells, promote to row/column
    * - If too many rows/columns, promote to full redraw
    */
-  optimize(thresholds: {
-    maxCells?: number;
-    maxRows?: number;
-    maxColumns?: number;
-  } = {}): void {
-    const {
-      maxCells = 50,
-      maxRows = 100,
-      maxColumns = 20,
-    } = thresholds;
+  optimize(thresholds: { maxCells?: number; maxRows?: number; maxColumns?: number } = {}): void {
+    const { maxCells = 50, maxRows = 100, maxColumns = 20 } = thresholds;
 
     // If too many cells, check if we should promote to rows
     if (this.damagedCells.size > maxCells) {
@@ -361,8 +350,7 @@ export function getDirtyBounds(
 
     const width = columnWidths[col] || 0;
 
-    if (x + width >= 0 && x <= viewportWidth &&
-        y + rowHeight >= 0 && y <= viewportHeight) {
+    if (x + width >= 0 && x <= viewportWidth && y + rowHeight >= 0 && y <= viewportHeight) {
       rects.push({
         x: Math.max(0, x),
         y: Math.max(0, y),
@@ -420,4 +408,4 @@ export function mergeRectangles(rects: Rectangle[]): Rectangle[] {
   }
 
   return merged;
-}
+}

package/src/lib/rendering/utils/index.ts

@@ -4,4 +4,4 @@
  * Exports all utility modules.
  */
 
-export * from './damage-tracker';
+export * from './damage-tracker';

package/src/lib/services/grid.service.set-filter.spec.ts

@@ -0,0 +1,219 @@
+import { provideExperimentalZonelessChangeDetection } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { ColDef } from '../types/ag-grid-types';
+import { GridService } from './grid.service';
+
+describe('GridService - Set Filter', () => {
+  let service: GridService<any>;
+
+  const testColumnDefs: ColDef[] = [
+    { field: 'id', headerName: 'ID', width: 100, filter: 'text' },
+    { field: 'name', headerName: 'Name', width: 150, filter: 'text' },
+    { field: 'department', headerName: 'Department', width: 150, filter: 'set' },
+    { field: 'status', headerName: 'Status', width: 100, filter: 'set' },
+  ];
+
+  const testRowData = [
+    { id: 1, name: 'John', department: 'Engineering', status: 'active' },
+    { id: 2, name: 'Jane', department: 'Engineering', status: 'active' },
+    { id: 3, name: 'Bob', department: 'Sales', status: 'inactive' },
+    { id: 4, name: 'Alice', department: 'Sales', status: 'active' },
+    { id: 5, name: 'Charlie', department: 'Marketing', status: 'inactive' },
+  ];
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [GridService, provideExperimentalZonelessChangeDetection()],
+    });
+    service = TestBed.inject(GridService);
+  });
+
+  describe('getUniqueValues', () => {
+    it('should return unique values for a field', () => {
+      service.createApi(testColumnDefs, [...testRowData]);
+      const values = service.getUniqueValues('department');
+
+      expect(values).toEqual(['Engineering', 'Marketing', 'Sales']);
+    });
+
+    it('should return sorted values', () => {
+      service.createApi(testColumnDefs, [...testRowData]);
+      const values = service.getUniqueValues('status');
+
+      expect(values).toEqual(['active', 'inactive']);
+    });
+
+    it('should exclude null values', () => {
+      const dataWithNulls = [
+        { id: 1, department: 'Engineering' },
+        { id: 2, department: null },
+        { id: 3, department: 'Sales' },
+        { id: 4, department: undefined },
+      ];
+      service.createApi(testColumnDefs, dataWithNulls);
+      const values = service.getUniqueValues('department');
+
+      expect(values).toEqual(['Engineering', 'Sales']);
+    });
+
+    it('should return empty array for non-existent field', () => {
+      service.createApi(testColumnDefs, [...testRowData]);
+      const values = service.getUniqueValues('nonExistent');
+
+      expect(values).toEqual([]);
+    });
+
+    it('should handle numeric values', () => {
+      const numericData = [
+        { id: 1, count: 10 },
+        { id: 2, count: 20 },
+        { id: 3, count: 10 },
+        { id: 4, count: 30 },
+      ];
+      service.createApi(testColumnDefs, numericData);
+      const values = service.getUniqueValues('count');
+
+      expect(values).toEqual([10, 20, 30]);
+    });
+  });
+
+  describe('matchesSetFilter', () => {
+    it('should match value in filter array', () => {
+      const api = service.createApi(testColumnDefs, [...testRowData]);
+
+      // Apply set filter
+      api.setFilterModel({
+        department: { filterType: 'set', values: ['Engineering', 'Sales'] },
+      });
+
+      expect(api.getDisplayedRowCount()).toBe(4); // John, Jane, Bob, Alice
+    });
+
+    it('should not match value not in filter array', () => {
+      const api = service.createApi(testColumnDefs, [...testRowData]);
+
+      // Apply set filter excluding Engineering
+      api.setFilterModel({
+        department: { filterType: 'set', values: ['Sales', 'Marketing'] },
+      });
+
+      expect(api.getDisplayedRowCount()).toBe(3); // Bob, Alice, Charlie
+    });
+
+    it('should return all rows when filter is empty array', () => {
+      const api = service.createApi(testColumnDefs, [...testRowData]);
+
+      // Empty filter = no filter applied
+      api.setFilterModel({
+        department: { filterType: 'set', values: [] },
+      });
+
+      expect(api.getDisplayedRowCount()).toBe(5); // All rows
+    });
+
+    it('should work with numeric values', () => {
+      const numericData = [
+        { id: 1, name: 'A', department: 'Eng', status: 10 },
+        { id: 2, name: 'B', department: 'Eng', status: 20 },
+        { id: 3, name: 'C', department: 'Eng', status: 30 },
+      ];
+      const api = service.createApi(testColumnDefs, numericData);
+
+      api.setFilterModel({
+        status: { filterType: 'set', values: [10, 30] },
+      });
+
+      expect(api.getDisplayedRowCount()).toBe(2); // id 1 and 3
+    });
+
+    it('should handle null/undefined values correctly', () => {
+      const dataWithNulls = [
+        { id: 1, status: 'active' },
+        { id: 2, status: null },
+        { id: 3, status: 'inactive' },
+        { id: 4, status: undefined },
+      ];
+      const api = service.createApi(testColumnDefs, dataWithNulls);
+
+      api.setFilterModel({
+        status: { filterType: 'set', values: ['active'] },
+      });
+
+      expect(api.getDisplayedRowCount()).toBe(1); // Only active
+    });
+
+    it('should combine with other filters', () => {
+      const api = service.createApi(testColumnDefs, [...testRowData]);
+
+      // Combine set filter with text filter
+      api.setFilterModel({
+        department: { filterType: 'set', values: ['Engineering', 'Sales'] },
+        name: { filterType: 'text', type: 'contains', filter: 'o' },
+      });
+
+      expect(api.getDisplayedRowCount()).toBe(2); // Bob (Sales) and John (Engineering)
+    });
+
+    it('should update when filter changes', () => {
+      const api = service.createApi(testColumnDefs, [...testRowData]);
+
+      // Initial filter
+      api.setFilterModel({
+        department: { filterType: 'set', values: ['Engineering'] },
+      });
+
+      expect(api.getDisplayedRowCount()).toBe(2); // John, Jane
+
+      // Change filter
+      api.setFilterModel({
+        department: { filterType: 'set', values: ['Sales'] },
+      });
+
+      expect(api.getDisplayedRowCount()).toBe(2); // Bob, Alice
+    });
+  });
+
+  describe('Set Filter API Integration', () => {
+    it('should get filter model with set filter', () => {
+      const api = service.createApi(testColumnDefs, [...testRowData]);
+
+      api.setFilterModel({
+        department: { filterType: 'set', values: ['Engineering'] },
+      });
+
+      const model = api.getFilterModel();
+      expect(model.department).toEqual({
+        filterType: 'set',
+        values: ['Engineering'],
+      });
+    });
+
+    it('should clear set filter', () => {
+      const api = service.createApi(testColumnDefs, [...testRowData]);
+
+      api.setFilterModel({
+        department: { filterType: 'set', values: ['Engineering'] },
+      });
+
+      // Clear filter
+      api.setFilterModel({});
+
+      const model = api.getFilterModel();
+      expect(model.department).toBeUndefined();
+    });
+
+    it('should work with getDisplayedRowCount', () => {
+      const api = service.createApi(testColumnDefs, [...testRowData]);
+
+      // No filter
+      expect(api.getDisplayedRowCount()).toBe(5);
+
+      // Apply set filter
+      api.setFilterModel({
+        department: { filterType: 'set', values: ['Engineering'] },
+      });
+
+      expect(api.getDisplayedRowCount()).toBe(2);
+    });
+  });
+});