@jmruthers/pace-core 0.2.7 → 0.5.1

package/src/components/DataTable/utils/__tests__/performanceUtils.unit.test.ts

@@ -1,414 +0,0 @@
-/**
- * @file Performance Utils Unit Tests
- * @package @jmruthers/pace-core
- * @module Components/DataTable/Utils/Performance/Tests
- * @since 0.3.0
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import {
-  determinePaginationMode,
-  getOptimalPageSizeOptions,
-  chunkData,
-  DataChunkManager,
-  SearchIndex,
-  PerformanceMonitor,
-  debounce,
-  throttle,
-  VisibilityTracker,
-} from '../performanceUtils';
-import type { ChunkingConfig, SearchIndexConfig } from '../../types';
-
-describe('performanceUtils', () => {
-  describe('determinePaginationMode', () => {
-    it('should return client mode for small datasets', () => {
-      expect(determinePaginationMode(500)).toBe('client');
-      expect(determinePaginationMode(1000)).toBe('client');
-    });
-
-    it('should return hybrid mode for medium datasets', () => {
-      expect(determinePaginationMode(5000)).toBe('hybrid');
-      expect(determinePaginationMode(9000)).toBe('hybrid');
-    });
-
-    it('should return server mode for large datasets', () => {
-      expect(determinePaginationMode(15000)).toBe('server');
-      expect(determinePaginationMode(50000)).toBe('server');
-    });
-
-    it('should respect custom threshold', () => {
-      expect(determinePaginationMode(7000, 5000)).toBe('server');
-      expect(determinePaginationMode(3000, 5000)).toBe('hybrid');
-    });
-  });
-
-  describe('getOptimalPageSizeOptions', () => {
-    it('should return appropriate options for client mode', () => {
-      expect(getOptimalPageSizeOptions('client', 50)).toEqual([10, 25, 50]);
-      expect(getOptimalPageSizeOptions('client', 500)).toEqual([10, 25, 50, 100]);
-    });
-
-    it('should return appropriate options for hybrid mode', () => {
-      expect(getOptimalPageSizeOptions('hybrid', 5000)).toEqual([50, 100, 250, 500]);
-    });
-
-    it('should return appropriate options for server mode', () => {
-      expect(getOptimalPageSizeOptions('server', 50000)).toEqual([25, 50, 100, 250]);
-    });
-
-    it('should return default options for unknown mode', () => {
-      expect(getOptimalPageSizeOptions('unknown' as any, 1000)).toEqual([10, 25, 50, 100]);
-    });
-  });
-
-  describe('chunkData', () => {
-    const sampleData = Array.from({ length: 100 }, (_, i) => ({ id: i, name: `Item ${i}` }));
-
-    it('should split data into correct number of chunks', () => {
-      const chunks = chunkData(sampleData, 10);
-      expect(chunks).toHaveLength(10);
-      expect(chunks[0]).toHaveLength(10);
-      expect(chunks[9]).toHaveLength(10);
-    });
-
-    it('should handle uneven chunk sizes', () => {
-      const chunks = chunkData(sampleData, 30);
-      expect(chunks).toHaveLength(4);
-      expect(chunks[0]).toHaveLength(30);
-      expect(chunks[3]).toHaveLength(10); // Last chunk has remainder
-    });
-
-    it('should handle empty data', () => {
-      const chunks = chunkData([], 10);
-      expect(chunks).toHaveLength(0);
-    });
-
-    it('should handle chunk size larger than data', () => {
-      const smallData = [{ id: 1 }, { id: 2 }];
-      const chunks = chunkData(smallData, 10);
-      expect(chunks).toHaveLength(1);
-      expect(chunks[0]).toHaveLength(2);
-    });
-  });
-
-  describe('DataChunkManager', () => {
-    let manager: DataChunkManager<{ id: number; name: string }>;
-    const sampleData = Array.from({ length: 100 }, (_, i) => ({ id: i, name: `Item ${i}` }));
-    
-         beforeEach(() => {
-       const config: ChunkingConfig = {
-         chunkSize: 10,
-         maxChunksInMemory: 3,
-       };
-       manager = new DataChunkManager(config);
-     });
-
-    it('should return correct chunk data', () => {
-      const chunk = manager.getChunk(0, sampleData);
-      expect(chunk).toHaveLength(10);
-      expect(chunk[0]).toEqual({ id: 0, name: 'Item 0' });
-      expect(chunk[9]).toEqual({ id: 9, name: 'Item 9' });
-    });
-
-    it('should cache chunks in memory', () => {
-      const chunk1 = manager.getChunk(0, sampleData);
-      const chunk2 = manager.getChunk(0, sampleData); // Should return cached version
-      expect(chunk1).toBe(chunk2); // Same reference
-    });
-
-    it('should evict oldest chunks when at capacity', () => {
-      // Fill cache to capacity
-      manager.getChunk(0, sampleData);
-      manager.getChunk(1, sampleData);
-      manager.getChunk(2, sampleData);
-      
-      // Add one more to trigger eviction
-      manager.getChunk(3, sampleData);
-      
-      // Chunk 0 should be evicted, chunk 3 should be in memory
-      const memoryUsage = manager.getMemoryUsage();
-      expect(memoryUsage).toBeGreaterThan(0);
-    });
-
-    it('should update access order correctly', () => {
-      manager.getChunk(0, sampleData);
-      manager.getChunk(1, sampleData);
-      manager.getChunk(0, sampleData); // Access chunk 0 again
-      manager.getChunk(2, sampleData);
-      manager.getChunk(3, sampleData); // Should evict chunk 1, not 0
-      
-      expect(manager.getMemoryUsage()).toBeGreaterThan(0);
-    });
-
-    it('should handle edge case chunks', () => {
-      const lastChunk = manager.getChunk(9, sampleData); // Last complete chunk
-      expect(lastChunk).toHaveLength(10);
-      
-      const partialChunk = manager.getChunk(10, sampleData); // Partial chunk
-      expect(partialChunk).toHaveLength(0);
-    });
-
-    it('should clear all chunks', () => {
-      manager.getChunk(0, sampleData);
-      manager.getChunk(1, sampleData);
-      
-      manager.clear();
-      expect(manager.getMemoryUsage()).toBe(0);
-    });
-
-    it('should calculate memory usage correctly', () => {
-      manager.getChunk(0, sampleData);
-      const usage = manager.getMemoryUsage();
-      expect(usage).toBeGreaterThan(0);
-      expect(typeof usage).toBe('number');
-    });
-  });
-
-  describe('SearchIndex', () => {
-    let searchIndex: SearchIndex<{ id: number; name: string; email: string }>;
-    const sampleData = [
-      { id: 1, name: 'John Doe', email: 'john@example.com' },
-      { id: 2, name: 'Jane Smith', email: 'jane@example.com' },
-      { id: 3, name: 'Bob Johnson', email: 'bob@company.com' },
-      { id: 4, name: 'Alice Brown', email: 'alice@test.org' },
-    ];
-
-    beforeEach(() => {
-      const config: SearchIndexConfig = {
-        indexedFields: ['name', 'email'],
-        fuzzySearch: false,
-      };
-      searchIndex = new SearchIndex(config);
-      searchIndex.buildIndex(sampleData);
-    });
-
-    it('should build index correctly', () => {
-      const results = searchIndex.search('john');
-      expect(results).toContain(0); // John Doe
-      // Note: Bob Johnson contains 'johnson' not 'john' - this was an incorrect expectation
-    });
-
-    it('should handle exact word matches', () => {
-      const results = searchIndex.search('doe');
-      expect(results).toEqual([0]); // Only John Doe
-    });
-
-    it('should handle email searches', () => {
-      const results = searchIndex.search('example.com');
-      expect(results).toContain(0); // John
-      expect(results).toContain(1); // Jane
-      expect(results).not.toContain(2); // Bob has company.com
-    });
-
-    it('should handle multiple search terms', () => {
-      const results = searchIndex.search('jane smith');
-      expect(results).toEqual([1]); // Should find Jane Smith
-    });
-
-    it('should return empty array for empty query', () => {
-      const results = searchIndex.search('');
-      expect(results).toEqual([]);
-    });
-
-    it('should handle case insensitive search', () => {
-      const results = searchIndex.search('JOHN');
-      expect(results).toContain(0); // John Doe
-      // Bob Johnson contains 'johnson' not 'john'
-    });
-
-    describe('with fuzzy search', () => {
-      beforeEach(() => {
-        const config: SearchIndexConfig = {
-          indexedFields: ['name', 'email'],
-          fuzzySearch: true,
-          fuzzyThreshold: 0.6,
-        };
-        searchIndex = new SearchIndex(config);
-        searchIndex.buildIndex(sampleData);
-      });
-
-      it('should find fuzzy matches', () => {
-        const results = searchIndex.search('johnn'); // Typo in 'john'
-        expect(results.length).toBeGreaterThan(0);
-      });
-
-      it('should respect fuzzy threshold', () => {
-        const results = searchIndex.search('xyz'); // Very different
-        expect(results).toEqual([]);
-      });
-    });
-
-    it('should handle nested field paths', () => {
-      const nestedData = [
-        { id: 1, profile: { name: 'John', details: { email: 'john@example.com' } } },
-      ];
-      
-      const config: SearchIndexConfig = {
-        indexedFields: ['profile.name', 'profile.details.email'],
-        fuzzySearch: false,
-      };
-      
-      const nestedIndex = new SearchIndex(config);
-      nestedIndex.buildIndex(nestedData);
-      
-      const results = nestedIndex.search('john');
-      expect(results).toEqual([0]);
-    });
-  });
-
-
-  describe('debounce', () => {
-    beforeEach(() => {
-      vi.useFakeTimers();
-    });
-
-    afterEach(() => {
-      vi.useRealTimers();
-    });
-
-    it('should debounce function calls', () => {
-      const mockFn = vi.fn();
-      const debouncedFn = debounce(mockFn, 100);
-
-      debouncedFn('arg1');
-      debouncedFn('arg2');
-      debouncedFn('arg3');
-
-      expect(mockFn).not.toHaveBeenCalled();
-
-      vi.advanceTimersByTime(100);
-
-      expect(mockFn).toHaveBeenCalledTimes(1);
-      expect(mockFn).toHaveBeenCalledWith('arg3');
-    });
-
-    it('should reset debounce timer on new calls', () => {
-      const mockFn = vi.fn();
-      const debouncedFn = debounce(mockFn, 100);
-
-      debouncedFn('arg1');
-      vi.advanceTimersByTime(50);
-      
-      debouncedFn('arg2');
-      vi.advanceTimersByTime(50);
-      
-      expect(mockFn).not.toHaveBeenCalled();
-      
-      vi.advanceTimersByTime(50);
-      expect(mockFn).toHaveBeenCalledWith('arg2');
-    });
-
-    afterEach(() => {
-      vi.clearAllTimers();
-    });
-  });
-
-  describe('throttle', () => {
-    beforeEach(() => {
-      vi.useFakeTimers();
-    });
-
-    afterEach(() => {
-      vi.useRealTimers();
-    });
-
-    it('should throttle function calls', () => {
-      const mockFn = vi.fn();
-      const throttledFn = throttle(mockFn, 100);
-
-      throttledFn('arg1');
-      throttledFn('arg2');
-      throttledFn('arg3');
-
-      expect(mockFn).toHaveBeenCalledTimes(1);
-      expect(mockFn).toHaveBeenCalledWith('arg1');
-
-      vi.advanceTimersByTime(100);
-
-      throttledFn('arg4');
-      expect(mockFn).toHaveBeenCalledTimes(2);
-      expect(mockFn).toHaveBeenCalledWith('arg4');
-    });
-
-    it('should not call function before throttle delay', () => {
-      const mockFn = vi.fn();
-      const throttledFn = throttle(mockFn, 100);
-
-      throttledFn('arg1');
-      vi.advanceTimersByTime(50);
-      throttledFn('arg2');
-
-      expect(mockFn).toHaveBeenCalledTimes(1);
-      expect(mockFn).toHaveBeenCalledWith('arg1');
-    });
-
-    afterEach(() => {
-      vi.clearAllTimers();
-    });
-  });
-
-  describe('VisibilityTracker', () => {
-    let tracker: VisibilityTracker;
-    let mockElement: Element;
-    let mockObserver: any;
-
-    beforeEach(() => {
-      // Mock IntersectionObserver
-      mockObserver = {
-        observe: vi.fn(),
-        unobserve: vi.fn(),
-        disconnect: vi.fn(),
-      } as any;
-
-      (global as any).IntersectionObserver = vi.fn().mockImplementation(() => mockObserver);
-
-      tracker = new VisibilityTracker();
-      mockElement = document.createElement('div');
-    });
-
-    it('should create IntersectionObserver on construction', () => {
-      expect(global.IntersectionObserver).toHaveBeenCalled();
-    });
-
-    it('should observe elements', () => {
-      tracker.observe(mockElement);
-      expect(mockObserver.observe).toHaveBeenCalledWith(mockElement);
-    });
-
-    it('should unobserve elements', () => {
-      tracker.unobserve(mockElement);
-      expect(mockObserver.unobserve).toHaveBeenCalledWith(mockElement);
-    });
-
-    it('should register visibility change callbacks', () => {
-      const callback = vi.fn();
-      const unsubscribe = tracker.onVisibilityChange(callback);
-      
-      expect(typeof unsubscribe).toBe('function');
-    });
-
-    it('should return visible count', () => {
-      const count = tracker.getVisibleCount();
-      expect(typeof count).toBe('number');
-      expect(count).toBe(0); // Initially no visible elements
-    });
-
-    it('should clean up on destroy', () => {
-      tracker.destroy();
-      expect(mockObserver.disconnect).toHaveBeenCalled();
-    });
-
-    it('should handle callback unsubscription', () => {
-      const callback = vi.fn();
-      const unsubscribe = tracker.onVisibilityChange(callback);
-      
-      unsubscribe();
-      // Should not throw error
-    });
-
-    afterEach(() => {
-      tracker.destroy();
-      delete (global as any).IntersectionObserver;
-    });
-  });
-});