@jmruthers/pace-core 0.5.3 → 0.5.5

package/src/utils/__tests__/bundleAnalysis.unit.test.ts

@@ -0,0 +1,317 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+describe('bundleAnalysis', () => {
+  let consoleSpy: {
+    log: ReturnType<typeof vi.spyOn>;
+    warn: ReturnType<typeof vi.spyOn>;
+    group: ReturnType<typeof vi.spyOn>;
+    groupEnd: ReturnType<typeof vi.spyOn>;
+  };
+
+  beforeEach(() => {
+    // Mock console methods before each test
+    consoleSpy = {
+      log: vi.spyOn(console, 'log').mockImplementation(() => {}),
+      warn: vi.spyOn(console, 'warn').mockImplementation(() => {}),
+      group: vi.spyOn(console, 'group').mockImplementation(() => {}),
+      groupEnd: vi.spyOn(console, 'groupEnd').mockImplementation(() => {})
+    };
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('bundleAnalyzer.analyzeBundle', () => {
+    it('should return null in production mode', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'production';
+
+      // Clear module cache and re-import
+      vi.resetModules();
+      const { bundleAnalyzer } = await import('../bundleAnalysis');
+      const result = bundleAnalyzer.analyzeBundle();
+
+      expect(result).toBeNull();
+
+      process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should return bundle stats in development mode', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'development';
+
+      // Clear module cache and re-import to pick up environment change
+      vi.resetModules();
+      const { bundleAnalyzer } = await import('../bundleAnalysis');
+      const result = bundleAnalyzer.analyzeBundle();
+
+      expect(result).toEqual({
+        totalSize: 0,
+        gzippedSize: 0,
+        chunks: [],
+        treeshakingEffectiveness: 0
+      });
+
+      process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should log bundle analysis instructions in development mode', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'development';
+
+      // Clear module cache and re-import to pick up environment change
+      vi.resetModules();
+      const { bundleAnalyzer } = await import('../bundleAnalysis');
+      bundleAnalyzer.analyzeBundle();
+
+      expect(consoleSpy.log).toHaveBeenCalledWith('Bundle analysis would run here in development');
+      expect(consoleSpy.log).toHaveBeenCalledWith('To enable real bundle analysis:');
+      expect(consoleSpy.log).toHaveBeenCalledWith('1. Install webpack-bundle-analyzer');
+      expect(consoleSpy.log).toHaveBeenCalledWith('2. Add bundle analysis to build scripts');
+      expect(consoleSpy.log).toHaveBeenCalledWith('3. Integrate with performance budgets');
+
+      process.env.NODE_ENV = originalEnv;
+    });
+  });
+
+  describe('bundleAnalyzer.checkTreeshaking', () => {
+    it('should do nothing in production mode', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'production';
+
+      vi.resetModules();
+      const { bundleAnalyzer } = await import('../bundleAnalysis');
+      bundleAnalyzer.checkTreeshaking();
+
+      expect(consoleSpy.group).not.toHaveBeenCalled();
+
+      process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should log treeshaking analysis in development mode', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'development';
+
+      // Clear module cache and re-import to pick up environment change
+      vi.resetModules();
+      const { bundleAnalyzer } = await import('../bundleAnalysis');
+      bundleAnalyzer.checkTreeshaking();
+
+      expect(consoleSpy.group).toHaveBeenCalledWith('Tree-shaking Analysis');
+      expect(consoleSpy.log).toHaveBeenCalledWith('- Check for unused exports in index files');
+      expect(consoleSpy.log).toHaveBeenCalledWith('- Verify side-effect free modules in package.json');
+      expect(consoleSpy.log).toHaveBeenCalledWith('- Ensure proper ES module syntax');
+      expect(consoleSpy.log).toHaveBeenCalledWith('- Check for circular dependencies');
+      expect(consoleSpy.groupEnd).toHaveBeenCalled();
+
+      process.env.NODE_ENV = originalEnv;
+    });
+  });
+
+  describe('bundleAnalyzer.validateExports', () => {
+    it('should do nothing in production mode', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'production';
+
+      vi.resetModules();
+      const { bundleAnalyzer } = await import('../bundleAnalysis');
+      bundleAnalyzer.validateExports();
+
+      expect(consoleSpy.group).not.toHaveBeenCalled();
+
+      process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should log export validation in development mode', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'development';
+
+      // Clear module cache and re-import to pick up environment change
+      vi.resetModules();
+      const { bundleAnalyzer } = await import('../bundleAnalysis');
+      bundleAnalyzer.validateExports();
+
+      expect(consoleSpy.group).toHaveBeenCalledWith('Export Validation');
+      expect(consoleSpy.log).toHaveBeenCalledWith('Checking for optimal export patterns...');
+      expect(consoleSpy.log).toHaveBeenCalledWith('- Prefer named exports over default exports');
+      expect(consoleSpy.log).toHaveBeenCalledWith('- Avoid barrel exports for large modules');
+      expect(consoleSpy.log).toHaveBeenCalledWith('- Use dynamic imports for large dependencies');
+      expect(consoleSpy.groupEnd).toHaveBeenCalled();
+
+      process.env.NODE_ENV = originalEnv;
+    });
+  });
+
+  describe('bundleAnalyzer.generateReport', () => {
+    it('should generate a comprehensive bundle analysis report', async () => {
+      vi.resetModules();
+      const { bundleAnalyzer } = await import('../bundleAnalysis');
+      const report = bundleAnalyzer.generateReport();
+
+      expect(report).toContain('# Bundle Analysis Report');
+      expect(report).toContain('## Recommendations for @jmruthers/pace-core');
+      expect(report).toContain('### 1. Code Splitting Opportunities');
+      expect(report).toContain('### 2. Tree-shaking Optimization');
+      expect(report).toContain('### 3. Bundle Size Targets');
+      expect(report).toContain('### 4. Performance Monitoring');
+      expect(report).toContain('✅ DataTable virtualization is lazy-loaded');
+      expect(report).toContain('⚠️  Consider splitting auth providers by use case');
+      expect(report).toContain('Core components: < 50KB gzipped');
+      expect(report).toContain('Total package: < 150KB gzipped');
+    });
+
+    it('should include specific recommendations', async () => {
+      vi.resetModules();
+      const { bundleAnalyzer } = await import('../bundleAnalysis');
+      const report = bundleAnalyzer.generateReport();
+
+      expect(report).toContain('Lazy load heavy UI components (charts, complex forms)');
+      expect(report).toContain('Check for unused utility functions');
+      expect(report).toContain('Monitor component render times');
+      expect(report).toContain('Track bundle size changes');
+      expect(report).toContain('Validate tree-shaking effectiveness');
+    });
+  });
+
+  describe('validateImportPattern', () => {
+    it('should do nothing in production mode', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'production';
+
+      vi.resetModules();
+      const { validateImportPattern } = await import('../bundleAnalysis');
+      validateImportPattern('lodash', ['debounce', 'throttle']);
+
+      expect(consoleSpy.warn).not.toHaveBeenCalled();
+
+      process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should warn about large imports from large modules', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'development';
+
+      vi.resetModules();
+      const { validateImportPattern } = await import('../bundleAnalysis');
+      validateImportPattern('lodash', ['debounce', 'throttle', 'map', 'filter', 'reduce', 'forEach']);
+
+      expect(consoleSpy.warn).toHaveBeenCalledWith(
+        'Large import detected: importing 6 items from lodash. ' +
+        'Consider splitting imports or using more specific imports.'
+      );
+
+      process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should not warn for small imports from large modules', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'development';
+
+      vi.resetModules();
+      const { validateImportPattern } = await import('../bundleAnalysis');
+      validateImportPattern('lodash', ['debounce', 'throttle']);
+
+      expect(consoleSpy.warn).not.toHaveBeenCalled();
+
+      process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should not warn for large imports from small modules', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'development';
+
+      vi.resetModules();
+      const { validateImportPattern } = await import('../bundleAnalysis');
+      validateImportPattern('small-module', ['func1', 'func2', 'func3', 'func4', 'func5', 'func6']);
+
+      expect(consoleSpy.warn).not.toHaveBeenCalled();
+
+      process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should detect lodash as large module', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'development';
+
+      vi.resetModules();
+      const { validateImportPattern } = await import('../bundleAnalysis');
+      validateImportPattern('lodash-es', ['debounce', 'throttle', 'map', 'filter', 'reduce', 'forEach']);
+
+      expect(consoleSpy.warn).toHaveBeenCalled();
+
+      process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should detect moment as large module', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'development';
+
+      vi.resetModules();
+      const { validateImportPattern } = await import('../bundleAnalysis');
+      validateImportPattern('moment', ['format', 'parse', 'add', 'subtract', 'diff', 'isValid']);
+
+      expect(consoleSpy.warn).toHaveBeenCalled();
+
+      process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should detect rxjs as large module', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'development';
+
+      vi.resetModules();
+      const { validateImportPattern } = await import('../bundleAnalysis');
+      validateImportPattern('rxjs', ['Observable', 'Subject', 'BehaviorSubject', 'map', 'filter', 'switchMap']);
+
+      expect(consoleSpy.warn).toHaveBeenCalled();
+
+      process.env.NODE_ENV = originalEnv;
+    });
+  });
+
+  describe('trackDynamicImport', () => {
+    it('should do nothing in production mode', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'production';
+
+      vi.resetModules();
+      const { trackDynamicImport } = await import('../bundleAnalysis');
+      trackDynamicImport('some-module');
+
+      expect(consoleSpy.log).not.toHaveBeenCalled();
+
+      process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should log dynamic imports in development mode', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'development';
+
+      vi.resetModules();
+      const { trackDynamicImport } = await import('../bundleAnalysis');
+      trackDynamicImport('react-hook-form');
+
+      expect(consoleSpy.log).toHaveBeenCalledWith(
+        'Dynamic import: react-hook-form - Good for code splitting!'
+      );
+
+      process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should log different module names', async () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'development';
+
+      vi.resetModules();
+      const { trackDynamicImport } = await import('../bundleAnalysis');
+      trackDynamicImport('date-fns');
+
+      expect(consoleSpy.log).toHaveBeenCalledWith(
+        'Dynamic import: date-fns - Good for code splitting!'
+      );
+
+      process.env.NODE_ENV = originalEnv;
+    });
+  });
+}); 

package/src/utils/__tests__/cn.unit.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+import { cn } from '../cn';
+
+describe('cn utility', () => {
+  it('should merge class names correctly', () => {
+    expect(cn('class1', 'class2')).toBe('class1 class2');
+  });
+
+  it('should handle conditional classes', () => {
+    expect(cn('base', true && 'conditional')).toBe('base conditional');
+    expect(cn('base', false && 'conditional')).toBe('base');
+  });
+
+  it('should filter out falsy values', () => {
+    expect(cn('base', null, undefined, false, '', 'valid')).toBe('base valid');
+  });
+
+  it('should handle arrays', () => {
+    expect(cn('base', ['class1', 'class2'])).toBe('base class1 class2');
+  });
+
+  it('should handle objects', () => {
+    expect(cn('base', { conditional: true, ignored: false })).toBe('base conditional');
+  });
+
+  it('should handle mixed inputs', () => {
+    expect(cn('base', 'static', { conditional: true }, ['array1', 'array2'])).toBe('base static conditional array1 array2');
+  });
+
+  it('should handle empty inputs', () => {
+    expect(cn()).toBe('');
+    expect(cn('')).toBe('');
+  });
+});