@jmruthers/pace-core 0.5.135 → 0.5.137

package/src/utils/performance/performanceBenchmark.ts

@@ -0,0 +1,64 @@
+/**
+ * Performance benchmarking utilities
+ */
+
+export interface PerformanceMetrics {
+  renderTime: number;
+  interactionTime: number;
+  memoryUsage: number;
+  bundleSize: number;
+}
+
+export function createPerformanceBenchmark(name: string) {
+  const startTime = performance.now();
+  const startMemory = (performance as any).memory?.usedJSHeapSize || 0;
+
+  return {
+    end: () => {
+      const endTime = performance.now();
+      const endMemory = (performance as any).memory?.usedJSHeapSize || 0;
+      
+      const metrics: PerformanceMetrics = {
+        renderTime: endTime - startTime,
+        interactionTime: 0, // Would be measured separately
+        memoryUsage: endMemory - startMemory,
+        bundleSize: 0, // Would be measured at build time
+      };
+
+      // TODO: Replace with proper logging service integration
+      // For now, we'll use a no-op to prevent console pollution
+      const _unused = { 
+        benchmark: `Performance Benchmark [${name}]`, 
+        metrics 
+      };
+      
+      return metrics;
+    }
+  };
+}
+
+export function measureRenderPerformance(componentName: string, renderFn: () => void): PerformanceMetrics {
+  const startTime = performance.now();
+  const startMemory = (performance as any).memory?.usedJSHeapSize || 0;
+  
+  renderFn();
+  
+  const endTime = performance.now();
+  const endMemory = (performance as any).memory?.usedJSHeapSize || 0;
+  
+  const metrics: PerformanceMetrics = {
+    renderTime: endTime - startTime,
+    interactionTime: 0,
+    memoryUsage: endMemory - startMemory,
+    bundleSize: 0,
+  };
+  
+  // TODO: Replace with proper logging service integration
+  // For now, we'll use a no-op to prevent console pollution
+  const _unused = { 
+    benchmark: `Render Performance [${componentName}]`, 
+    metrics 
+  };
+  
+  return metrics;
+} 

package/src/utils/performance/performanceBudgets.ts

@@ -0,0 +1,110 @@
+
+interface PerformanceBudget {
+  metric: string;
+  budget: number;
+  actual: number;
+  threshold: 'error' | 'warning' | 'info';
+}
+
+interface PerformanceMetrics {
+  bundleSize: number;
+  chunkCount: number;
+  treeshakingEffectiveness: number;
+  dynamicImportUsage: number;
+}
+
+interface MeasurementResult {
+  passed: boolean;
+  value: number;
+  threshold: number;
+}
+
+// Performance budget thresholds with index signature
+export const PERFORMANCE_BUDGETS: { [key: string]: { threshold: number } } = {
+  COMPONENT_RENDER: { threshold: 50 },
+  BUNDLE_SIZE: { threshold: 150000 },
+  CHUNK_COUNT: { threshold: 10 },
+  TREESHAKING_SCORE: { threshold: 70 },
+  ERROR_BOUNDARY_TRIGGER: { threshold: 5 },
+  MEMORY_INCREASE: { threshold: 1000 },
+  LARGE_LIST_RENDER: { threshold: 500 },
+} as const;
+
+class PerformanceBudgetMonitor {
+  private metrics: Map<string, number> = new Map();
+  private budgets: PerformanceBudget[] = [];
+
+  measure(metric: string, value: number, metadata?: Record<string, unknown>): MeasurementResult {
+    this.metrics.set(metric, value);
+    
+    // In production, this would send to a proper logging service
+    // For now, we'll log to console for testing purposes
+    if (import.meta.env.MODE === 'development' || import.meta.env.MODE === 'test' || process.env.NODE_ENV === 'test') {
+      console.log('📊 Performance Metric: ' + metric + ' = ' + value, metadata);
+    }
+
+    // Get threshold for this metric
+    const budgetConfig = PERFORMANCE_BUDGETS[metric];
+    const threshold = budgetConfig?.threshold || 100;
+    const passed = value <= threshold;
+
+    return {
+      passed,
+      value,
+      threshold
+    };
+  }
+
+  setBudget(metric: string, budget: number, threshold: 'error' | 'warning' | 'info' = 'warning'): void {
+    this.budgets.push({ metric, budget, actual: 0, threshold });
+  }
+
+  checkBudgets(): PerformanceBudget[] {
+    const violations: PerformanceBudget[] = [];
+    
+    for (const budget of this.budgets) {
+      const actual = this.metrics.get(budget.metric) || 0;
+      budget.actual = actual;
+      
+      if (actual > budget.budget) {
+        violations.push(budget);
+        
+        // In production, this would send to a proper logging service
+        // For now, we'll log to console for testing purposes
+        if (import.meta.env.MODE === 'development' || import.meta.env.MODE === 'test' || process.env.NODE_ENV === 'test') {
+          if (budget.threshold === 'error') {
+            console.error('❌ Performance budget exceeded: ' + budget.metric + ' (' + actual + ' > ' + budget.budget + ')');
+          } else if (budget.threshold === 'warning') {
+            console.warn('⚠️ Performance budget exceeded: ' + budget.metric + ' (' + actual + ' > ' + budget.budget + ')');
+          } else {
+            console.info('ℹ️ Performance budget exceeded: ' + budget.metric + ' (' + actual + ' > ' + budget.budget + ')');
+          }
+        }
+      }
+    }
+    
+    return violations;
+  }
+
+  getMetrics(): PerformanceMetrics {
+    return {
+      bundleSize: this.metrics.get('BUNDLE_SIZE') || 0,
+      chunkCount: this.metrics.get('CHUNK_COUNT') || 0,
+      treeshakingEffectiveness: this.metrics.get('TREESHAKING_SCORE') || 0,
+      dynamicImportUsage: this.metrics.get('DYNAMIC_IMPORTS') || 0,
+    };
+  }
+
+  reset(): void {
+    this.metrics.clear();
+    this.budgets.length = 0;
+  }
+}
+
+export const performanceBudgetMonitor = new PerformanceBudgetMonitor();
+
+// Set default performance budgets
+performanceBudgetMonitor.setBudget('BUNDLE_SIZE', 150000, 'error'); // 150KB
+performanceBudgetMonitor.setBudget('CHUNK_COUNT', 10, 'warning');
+performanceBudgetMonitor.setBudget('TREESHAKING_SCORE', 70, 'warning');
+performanceBudgetMonitor.setBudget('ERROR_BOUNDARY_TRIGGER', 5, 'error');

package/src/utils/permissions/permissionTypes.ts

@@ -0,0 +1,37 @@
+
+/**
+ * @file Permission type definitions and utilities
+ */
+
+export enum PermissionType {
+  READ = 'read',
+  WRITE = 'write',
+  DELETE = 'delete',
+  ADMIN = 'admin'
+}
+
+/**
+ * Parse a permission string into components
+ */
+export function parsePermission(permission: string): { resource: string; action: string } | null {
+  if (!permission || typeof permission !== 'string') {
+    return null;
+  }
+  
+  const parts = permission.split(':');
+  if (parts.length !== 2) {
+    return null;
+  }
+  
+  const [action, resource] = parts;
+  
+  // Check that both action and resource exist and are not empty
+  if (action === undefined || resource === undefined || action === '' || resource === '') {
+    return null;
+  }
+  
+  return {
+    resource,
+    action
+  };
+}

package/src/utils/permissions/permissionUtils.test.ts

@@ -0,0 +1,393 @@
+/**
+ * @file Permission Utils Tests
+ * @package @jmruthers/pace-core
+ * @module Utils/PermissionUtils
+ * @since 1.0.0
+ * 
+ * Comprehensive tests for permission utility functions covering all critical functionality.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  transformPermissionMapToBoolean,
+  hasPermission,
+  hasAnyPermission,
+  hasAllPermissions
+} from './permissionUtils';
+
+describe('Permission Utils', () => {
+  describe('transformPermissionMapToBoolean', () => {
+    it('transforms string values correctly', () => {
+      const permissions = {
+        'read:users': 'true',
+        'write:users': 'false',
+        'delete:users': '',
+        'manage:users': 'yes',
+        'view:users': 'no'
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({
+        'read:users': true,
+        'write:users': false,
+        'delete:users': false,
+        'manage:users': true,
+        'view:users': true
+      });
+    });
+
+    it('transforms boolean values correctly', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true,
+        'manage:users': false
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true,
+        'manage:users': false
+      });
+    });
+
+    it('transforms mixed types correctly', () => {
+      const permissions = {
+        'read:users': 'true',
+        'write:users': false,
+        'delete:users': 1,
+        'manage:users': 0,
+        'view:users': null,
+        'edit:users': undefined
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true,
+        'manage:users': false,
+        'view:users': false,
+        'edit:users': false
+      });
+    });
+
+    it('handles empty object', () => {
+      const permissions = {};
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({});
+    });
+
+    it('handles null and undefined values', () => {
+      const permissions = {
+        'read:users': null,
+        'write:users': undefined,
+        'delete:users': false,
+        'manage:users': true
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({
+        'read:users': false,
+        'write:users': false,
+        'delete:users': false,
+        'manage:users': true
+      });
+    });
+
+    it('handles numeric values', () => {
+      const permissions = {
+        'read:users': 1,
+        'write:users': 0,
+        'delete:users': -1,
+        'manage:users': 42
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true,
+        'manage:users': true
+      });
+    });
+
+    it('handles case-insensitive string values', () => {
+      const permissions = {
+        'read:users': 'TRUE',
+        'write:users': 'FALSE',
+        'delete:users': 'True',
+        'manage:users': 'False'
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true,
+        'manage:users': false
+      });
+    });
+  });
+
+  describe('hasPermission', () => {
+    it('returns true for granted permission', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true
+      };
+
+      expect(hasPermission(permissions, 'read:users')).toBe(true);
+      expect(hasPermission(permissions, 'delete:users')).toBe(true);
+    });
+
+    it('returns false for denied permission', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true
+      };
+
+      expect(hasPermission(permissions, 'write:users')).toBe(false);
+    });
+
+    it('returns false for non-existent permission', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasPermission(permissions, 'manage:users')).toBe(false);
+    });
+
+    it('handles empty permissions object', () => {
+      const permissions = {};
+
+      expect(hasPermission(permissions, 'read:users')).toBe(false);
+    });
+
+    it('handles null/undefined permission', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasPermission(permissions, null as any)).toBe(false);
+      expect(hasPermission(permissions, undefined as any)).toBe(false);
+    });
+  });
+
+  describe('hasAnyPermission', () => {
+    it('returns true when at least one permission is granted', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': false
+      };
+
+      expect(hasAnyPermission(permissions, ['read:users', 'write:users'])).toBe(true);
+      expect(hasAnyPermission(permissions, ['write:users', 'delete:users', 'read:users'])).toBe(true);
+    });
+
+    it('returns false when no permissions are granted', () => {
+      const permissions = {
+        'read:users': false,
+        'write:users': false,
+        'delete:users': false
+      };
+
+      expect(hasAnyPermission(permissions, ['read:users', 'write:users'])).toBe(false);
+    });
+
+    it('returns false for empty permission list', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasAnyPermission(permissions, [])).toBe(false);
+    });
+
+    it('returns false when permission list contains non-existent permissions', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasAnyPermission(permissions, ['manage:users', 'admin:users'])).toBe(false);
+    });
+
+    it('handles mixed permission states', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true,
+        'manage:users': false
+      };
+
+      expect(hasAnyPermission(permissions, ['read:users', 'write:users'])).toBe(true);
+      expect(hasAnyPermission(permissions, ['write:users', 'manage:users'])).toBe(false);
+      expect(hasAnyPermission(permissions, ['delete:users', 'manage:users'])).toBe(true);
+    });
+
+    it('handles null/undefined permission list', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasAnyPermission(permissions, null as any)).toBe(false);
+      expect(hasAnyPermission(permissions, undefined as any)).toBe(false);
+    });
+  });
+
+  describe('hasAllPermissions', () => {
+    it('returns true when all permissions are granted', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': true,
+        'delete:users': true
+      };
+
+      expect(hasAllPermissions(permissions, ['read:users', 'write:users', 'delete:users'])).toBe(true);
+    });
+
+    it('returns false when at least one permission is denied', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true
+      };
+
+      expect(hasAllPermissions(permissions, ['read:users', 'write:users'])).toBe(false);
+      expect(hasAllPermissions(permissions, ['read:users', 'write:users', 'delete:users'])).toBe(false);
+    });
+
+    it('returns true for empty permission list', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasAllPermissions(permissions, [])).toBe(true);
+    });
+
+    it('returns false when permission list contains non-existent permissions', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': true
+      };
+
+      expect(hasAllPermissions(permissions, ['read:users', 'manage:users'])).toBe(false);
+    });
+
+    it('handles mixed permission states', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': true,
+        'delete:users': false,
+        'manage:users': true
+      };
+
+      expect(hasAllPermissions(permissions, ['read:users', 'write:users'])).toBe(true);
+      expect(hasAllPermissions(permissions, ['read:users', 'write:users', 'delete:users'])).toBe(false);
+      expect(hasAllPermissions(permissions, ['read:users', 'manage:users'])).toBe(true);
+    });
+
+    it('handles null/undefined permission list', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasAllPermissions(permissions, null as any)).toBe(false);
+      expect(hasAllPermissions(permissions, undefined as any)).toBe(false);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('handles very large permission objects', () => {
+      const permissions: Record<string, boolean> = {};
+      for (let i = 0; i < 1000; i++) {
+        permissions[`permission:${i}`] = i % 2 === 0;
+      }
+
+      const result = transformPermissionMapToBoolean(permissions);
+      expect(Object.keys(result)).toHaveLength(1000);
+      expect(result['permission:0']).toBe(true);
+      expect(result['permission:1']).toBe(false);
+    });
+
+    it('handles special characters in permission names', () => {
+      const permissions = {
+        'read:users@domain.com': true,
+        'write:users#special': false,
+        'delete:users$with$symbols': true,
+        'manage:users.with.dots': false
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+      expect(result['read:users@domain.com']).toBe(true);
+      expect(result['write:users#special']).toBe(false);
+      expect(result['delete:users$with$symbols']).toBe(true);
+      expect(result['manage:users.with.dots']).toBe(false);
+    });
+
+    it('handles unicode characters in permission names', () => {
+      const permissions = {
+        'read:用户': true,
+        'write:ユーザー': false,
+        'delete:مستخدم': true
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+      expect(result['read:用户']).toBe(true);
+      expect(result['write:ユーザー']).toBe(false);
+      expect(result['delete:مستخدم']).toBe(true);
+    });
+  });
+
+  describe('Type Safety', () => {
+    it('maintains type safety with TypeScript', () => {
+      const permissions: Record<string, boolean> = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      // These should compile without errors
+      const hasRead = hasPermission(permissions, 'read:users');
+      const hasAny = hasAnyPermission(permissions, ['read:users', 'write:users']);
+      const hasAll = hasAllPermissions(permissions, ['read:users']);
+
+      expect(typeof hasRead).toBe('boolean');
+      expect(typeof hasAny).toBe('boolean');
+      expect(typeof hasAll).toBe('boolean');
+    });
+
+    it('handles mixed input types gracefully', () => {
+      const permissions = {
+        'read:users': 'true',
+        'write:users': 1,
+        'delete:users': false,
+        'manage:users': null
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+      expect(typeof result['read:users']).toBe('boolean');
+      expect(typeof result['write:users']).toBe('boolean');
+      expect(typeof result['delete:users']).toBe('boolean');
+      expect(typeof result['manage:users']).toBe('boolean');
+    });
+  });
+});

package/src/utils/permissions/permissionUtils.ts

@@ -0,0 +1,34 @@
+
+/**
+ * Permission utilities for transforming and managing permissions
+ */
+
+export function transformPermissionMapToBoolean(permissions: Record<string, unknown>): Record<string, boolean> {
+  const result: Record<string, boolean> = {};
+  
+  Object.entries(permissions).forEach(([key, value]) => {
+    if (typeof value === 'string') {
+      // Handle string values - 'false' should be false, empty strings are false, other non-empty strings are true
+      result[key] = value !== '' && value.toLowerCase() !== 'false';
+    } else {
+      result[key] = Boolean(value);
+    }
+  });
+  
+  return result;
+}
+
+export function hasPermission(permissions: Record<string, boolean>, permission: string): boolean {
+  return Boolean(permissions[permission]);
+}
+
+export function hasAnyPermission(permissions: Record<string, boolean>, permissionList: string[] | null | undefined): boolean {
+  if (!permissionList || permissionList.length === 0) return false;
+  return permissionList.some(permission => hasPermission(permissions, permission));
+}
+
+export function hasAllPermissions(permissions: Record<string, boolean>, permissionList: string[] | null | undefined): boolean {
+  if (!permissionList) return false;
+  if (permissionList.length === 0) return true;
+  return permissionList.every(permission => hasPermission(permissions, permission));
+}