@jmruthers/pace-core 0.5.136 → 0.5.139

package/src/utils/auth-utils.ts

@@ -0,0 +1,96 @@
+/**
+ * @file Authentication utilities
+ */
+
+import type { User, SupabaseClient } from '@supabase/supabase-js';
+
+export interface LoginCredentials {
+  email: string;
+  password: string;
+}
+
+export interface SignUpData {
+  email: string;
+  password: string;
+}
+
+export interface AuthResponse {
+  user?: User;
+  error?: Error;
+}
+
+export async function signInWithEmail(credentials: LoginCredentials): Promise<AuthResponse> {
+  try {
+    // TODO: Implement actual authentication logic
+    // For now, return a proper error response indicating this needs implementation
+    return { 
+      error: new Error('Authentication not yet implemented - placeholder function') 
+    };
+  } catch (error) {
+    return { error: error instanceof Error ? error : new Error('Unknown authentication error') };
+  }
+}
+
+export async function signUpWithEmail(data: SignUpData): Promise<AuthResponse> {
+  try {
+    // TODO: Implement actual registration logic
+    // For now, return a proper error response indicating this needs implementation
+    return { 
+      error: new Error('Registration not yet implemented - placeholder function') 
+    };
+  } catch (error) {
+    return { error: error instanceof Error ? error : new Error('Unknown registration error') };
+  }
+}
+
+export async function resetPassword(email: string): Promise<{ error?: Error }> {
+  try {
+    // TODO: Implement actual password reset logic
+    // For now, return a proper error response indicating this needs implementation
+    return { 
+      error: new Error('Password reset not yet implemented - placeholder function') 
+    };
+  } catch (error) {
+    return { error: error instanceof Error ? error : new Error('Unknown password reset error') };
+  }
+}
+
+export async function updatePassword(supabaseClient: SupabaseClient, newPassword: string): Promise<{ error?: Error }> {
+  try {
+    const { error } = await supabaseClient.auth.updateUser({
+      password: newPassword
+    });
+    return { error: error || undefined };
+  } catch (err) {
+    return { error: err as Error };
+  }
+}
+
+// Audit logger implementation - using proper types instead of any
+export interface AuditEventDetails {
+  [key: string]: unknown;
+}
+
+export interface AuditEventData {
+  action: string;
+  details?: AuditEventDetails;
+}
+
+export const auditLogger = {
+  log: (event: string, details?: AuditEventDetails) => {
+    // TODO: Implement proper audit logging service integration
+    // Console logging removed for production
+  },
+  logAuthEvent: (userId: string, action: string, details?: AuditEventDetails) => {
+    // TODO: Implement proper auth event logging
+    // Console logging removed for production
+  },
+  logPermissionEvent: (userId: string, permission: string, granted: boolean) => {
+    // TODO: Implement proper permission event logging
+    // Console logging removed for production
+  },
+  logEvent: (eventData: AuditEventData) => {
+    // TODO: Implement proper event logging
+    // Console logging removed for production
+  }
+};

package/src/utils/bundleAnalysis.ts

@@ -0,0 +1,129 @@
+
+interface BundleStats {
+  totalSize: number;
+  gzippedSize: number;
+  chunks: ChunkInfo[];
+  treeshakingEffectiveness: number;
+}
+
+interface ChunkInfo {
+  name: string;
+  size: number;
+  modules: string[];
+  dynamicallyImported: boolean;
+}
+
+class BundleAnalyzer {
+  private enabled = import.meta.env.MODE === 'development';
+
+  analyzeBundle(): BundleStats | null {
+    if (!this.enabled) return null;
+
+    // In a real implementation, this would integrate with webpack-bundle-analyzer
+    // or similar tools. For now, we'll simulate analysis
+    
+    // TODO: Replace with proper logging service integration
+    // For now, we'll log to console for testing purposes
+    console.log('Bundle analysis would run here in development');
+    console.log('To enable real bundle analysis:');
+    console.log('1. Install webpack-bundle-analyzer');
+    console.log('2. Add bundle analysis to build scripts');
+    console.log('3. Integrate with performance budgets');
+
+    return {
+      totalSize: 0,
+      gzippedSize: 0,
+      chunks: [],
+      treeshakingEffectiveness: 0
+    };
+  }
+
+  checkTreeshaking(): void {
+    if (!this.enabled) return;
+
+    const potentialIssues = [
+      'Check for unused exports in index files',
+      'Verify side-effect free modules in package.json',
+      'Ensure proper ES module syntax',
+      'Check for circular dependencies'
+    ];
+
+    // TODO: Replace with proper logging service integration
+    // For now, we'll log to console for testing purposes
+    console.group('Tree-shaking Analysis');
+    potentialIssues.forEach(issue => console.log('- ' + issue));
+    console.groupEnd();
+  }
+
+  validateExports(): void {
+    if (!this.enabled) return;
+
+    // TODO: Replace with proper logging service integration
+    // For now, we'll log to console for testing purposes
+    console.group('Export Validation');
+    console.log('Checking for optimal export patterns...');
+    console.log('- Prefer named exports over default exports');
+    console.log('- Avoid barrel exports for large modules');
+    console.log('- Use dynamic imports for large dependencies');
+    console.groupEnd();
+  }
+
+  generateReport(): string {
+    const report = `
+# Bundle Analysis Report
+
+## Recommendations for @jmruthers/pace-core
+
+### 1. Code Splitting Opportunities
+- ✅ DataTable virtualization is lazy-loaded
+- ⚠️  Consider splitting auth providers by use case
+- ⚠️  Lazy load heavy UI components (charts, complex forms)
+
+### 2. Tree-shaking Optimization
+- ✅ Using ES modules throughout
+- ✅ Proper sideEffects configuration
+- ⚠️  Check for unused utility functions
+
+### 3. Bundle Size Targets
+- Core components: < 50KB gzipped
+- Auth module: < 30KB gzipped  
+- Utilities: < 20KB gzipped
+- Total package: < 150KB gzipped
+
+### 4. Performance Monitoring
+- Monitor component render times
+- Track bundle size changes
+- Validate tree-shaking effectiveness
+    `;
+
+    return report.trim();
+  }
+}
+
+export const bundleAnalyzer = new BundleAnalyzer();
+
+// Helper to check if imports are optimized
+export function validateImportPattern(moduleId: string, importedItems: string[]): void {
+  if (import.meta.env.MODE !== 'development') return;
+
+  const largeModules = ['lodash', 'moment', 'rxjs'];
+  const isLargeModule = largeModules.some(mod => moduleId.includes(mod));
+  
+  if (isLargeModule && importedItems.length > 5) {
+    // TODO: Replace with proper logging service integration
+    // For now, we'll log to console for testing purposes
+    console.warn(
+      'Large import detected: importing ' + importedItems.length + ' items from ' + moduleId + '. ' +
+      'Consider splitting imports or using more specific imports.'
+    );
+  }
+}
+
+// Monitor dynamic imports
+export function trackDynamicImport(moduleName: string): void {
+  if (import.meta.env.MODE !== 'development') return;
+  
+  // TODO: Replace with proper logging service integration
+  // For now, we'll log to console for testing purposes
+  console.log('Dynamic import: ' + moduleName + ' - Good for code splitting!');
+}

package/src/utils/cn.ts

@@ -0,0 +1,7 @@
+
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/src/utils/debugLogger.ts

@@ -0,0 +1,67 @@
+/**
+ * @file Debug Logger Utility
+ * @package @jmruthers/pace-core
+ * @module Utils/DebugLogger
+ * @since 0.4.76
+ */
+
+/**
+ * Debug logger that respects environment settings
+ * Only logs in development mode to prevent production console spam
+ */
+export class DebugLogger {
+  /**
+   * Check if we're in development mode
+   */
+  private static get isDevelopment(): boolean {
+    return import.meta.env.MODE === 'development';
+  }
+
+  /**
+   * Log debug information only in development mode
+   */
+  static log(component: string, message: string, ...args: any[]): void {
+    if (this.isDevelopment) {
+      try {
+        console.log(`[${component}] ${message}`, ...args);
+      } catch (e) {
+        // Gracefully handle console method errors
+      }
+    }
+  }
+
+  /**
+   * Log error information (always logged)
+   */
+  static error(component: string, message: string, ...args: any[]): void {
+    try {
+      console.error(`[${component}] ${message}`, ...args);
+    } catch (e) {
+      // Gracefully handle console method errors
+    }
+  }
+
+  /**
+   * Log warning information (always logged)
+   */
+  static warn(component: string, message: string, ...args: any[]): void {
+    try {
+      console.warn(`[${component}] ${message}`, ...args);
+    } catch (e) {
+      // Gracefully handle console method errors
+    }
+  }
+
+  /**
+   * Log info information only in development mode
+   */
+  static info(component: string, message: string, ...args: any[]): void {
+    if (this.isDevelopment) {
+      try {
+        console.info(`[${component}] ${message}`, ...args);
+      } catch (e) {
+        // Gracefully handle console method errors
+      }
+    }
+  }
+}

package/src/utils/deviceFingerprint.ts

@@ -0,0 +1,215 @@
+/**
+ * @file Secure Device Fingerprinting
+ * @description Enhanced device fingerprinting with encryption and security measures
+ */
+
+import { secureStorage } from './secureStorage';
+
+export interface DeviceFingerprint {
+  hash: string;
+  timestamp: number;
+  components: {
+    userAgent: string;
+    language: string;
+    platform: string;
+    screen: string;
+    timezone: string;
+    canvas?: string;
+    webgl?: string;
+  };
+  entropy: number;
+}
+
+/**
+ * Generate a secure device fingerprint (synchronous)
+ */
+export function generateDeviceFingerprint(): DeviceFingerprint {
+  try {
+    const components = {
+      userAgent: getHashedUserAgent(),
+      language: navigator.language || 'unknown',
+      platform: navigator.platform || 'unknown',
+      screen: `${screen.width}x${screen.height}x${screen.colorDepth}`,
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || 'unknown',
+      canvas: getCanvasFingerprint(),
+      webgl: getWebGLFingerprint(),
+    };
+
+    // Calculate entropy (uniqueness score)
+    const entropy = calculateEntropy(components);
+    
+    // Create a hash from all components
+    const fingerprintData = JSON.stringify(components);
+    const hash = hashStringSync(fingerprintData);
+
+    const fingerprint: DeviceFingerprint = {
+      hash,
+      timestamp: Date.now(),
+      components,
+      entropy,
+    };
+
+    // Store fingerprint asynchronously
+    secureStorage.setItem('device_fingerprint', JSON.stringify(fingerprint));
+    
+    return fingerprint;
+  } catch (error) {
+    return generateFallbackFingerprint();
+  }
+}
+
+/**
+ * Validate device fingerprint with security checks
+ */
+export function validateDeviceFingerprint(
+  storedFingerprint: DeviceFingerprint,
+  currentFingerprint: DeviceFingerprint
+): {
+  isValid: boolean;
+  confidence: number;
+  reasons: string[];
+} {
+  const reasons: string[] = [];
+  let matchingComponents = 0;
+  const totalComponents = Object.keys(storedFingerprint.components).length;
+
+  // Check each component
+  Object.entries(storedFingerprint.components).forEach(([key, value]) => {
+    if (currentFingerprint.components[key as keyof typeof currentFingerprint.components] === value) {
+      matchingComponents++;
+    } else {
+      reasons.push(`Component mismatch: ${key}`);
+    }
+  });
+
+  // Calculate confidence score
+  const confidence = (matchingComponents / totalComponents) * 100;
+
+  // Security thresholds
+  const isValid = confidence >= 80; // Require 80% match
+  
+  // Additional security checks
+  const timeDiff = currentFingerprint.timestamp - storedFingerprint.timestamp;
+  const maxAge = 30 * 24 * 60 * 60 * 1000; // 30 days
+  
+  if (timeDiff > maxAge) {
+    reasons.push('Fingerprint too old');
+    return { isValid: false, confidence, reasons };
+  }
+
+  if (confidence < 60) {
+    reasons.push('Device signature changed significantly');
+  }
+
+  return { isValid, confidence, reasons };
+}
+
+/**
+ * Generate canvas fingerprint for enhanced uniqueness
+ */
+function getCanvasFingerprint(): string {
+  try {
+    const canvas = document.createElement('canvas');
+    const ctx = canvas.getContext('2d');
+    
+    if (!ctx) return 'canvas-unavailable';
+
+    // Draw complex pattern for fingerprinting
+    ctx.textBaseline = 'top';
+    ctx.font = '14px Arial';
+    ctx.fillStyle = '#f60';
+    ctx.fillRect(125, 1, 62, 20);
+    ctx.fillStyle = '#069';
+    ctx.fillText('Device fingerprint 🔒', 2, 15);
+    ctx.fillStyle = 'rgba(102, 204, 0, 0.2)';
+    ctx.fillText('Device fingerprint 🔒', 4, 17);
+
+    const dataURL = canvas.toDataURL();
+    return hashStringSync(dataURL);
+  } catch (error) {
+    return 'canvas-error';
+  }
+}
+
+/**
+ * Get WebGL fingerprint
+ */
+function getWebGLFingerprint(): string {
+  try {
+    const canvas = document.createElement('canvas');
+    const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl') as WebGLRenderingContext | null;
+    
+    if (!gl) return 'webgl-unavailable';
+
+    const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+    if (!debugInfo) return 'webgl-no-debug';
+
+    const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
+    const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+    
+    return `${vendor}|${renderer}`;
+  } catch (error) {
+    return 'webgl-error';
+  }
+}
+
+/**
+ * Hash user agent to prevent direct exposure
+ */
+function getHashedUserAgent(): string {
+  const ua = navigator.userAgent;
+  return hashStringSync(ua).substring(0, 16); // Shorter hash for storage
+}
+
+/**
+ * Calculate entropy of fingerprint components
+ */
+function calculateEntropy(components: Record<string, string>): number {
+  const values = Object.values(components).join('');
+  const charCounts = new Map<string, number>();
+  
+  for (const char of values) {
+    charCounts.set(char, (charCounts.get(char) || 0) + 1);
+  }
+  
+  let entropy = 0;
+  for (const count of charCounts.values()) {
+    const probability = count / values.length;
+    entropy -= probability * Math.log2(probability);
+  }
+  
+  return entropy;
+}
+
+/**
+ * Synchronous hash function for device fingerprinting
+ */
+function hashStringSync(str: string): string {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = ((hash << 5) - hash) + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+
+/**
+ * Generate fallback fingerprint for error cases
+ */
+function generateFallbackFingerprint(): DeviceFingerprint {
+  const components = {
+    userAgent: 'fallback',
+    language: 'unknown',
+    platform: 'unknown',
+    screen: 'unknown',
+    timezone: 'unknown',
+  };
+
+  return {
+    hash: `fallback_${Date.now()}_${Math.random().toString(36)}`,
+    timestamp: Date.now(),
+    components,
+    entropy: 1, // Low entropy for fallback
+  };
+}

package/src/utils/dynamicUtils.ts

@@ -0,0 +1,105 @@
+
+/**
+ * Dynamic utility loader to reduce initial bundle size
+ * Heavy utilities are loaded on-demand
+ */
+
+// Type definitions for dynamic imports
+type DebounceFunction = <T extends (...args: unknown[]) => unknown>(
+  func: T,
+  wait?: number,
+  options?: { leading?: boolean; maxWait?: number; trailing?: boolean }
+) => T & { cancel(): void; flush(): void };
+
+type ThrottleFunction = <T extends (...args: unknown[]) => unknown>(
+  func: T,
+  wait?: number,
+  options?: { leading?: boolean; trailing?: boolean }
+) => T & { cancel(): void; flush(): void };
+
+// Dynamic lodash utilities
+export const loadLodash = async (): Promise<{
+  debounce: DebounceFunction;
+  throttle: ThrottleFunction;
+}> => {
+  const [debounceModule, throttleModule] = await Promise.all([
+    import('lodash.debounce' as any),
+    import('lodash.throttle' as any)
+  ]);
+  
+  return {
+    debounce: (debounceModule.default || debounceModule) as DebounceFunction,
+    throttle: (throttleModule.default || throttleModule) as ThrottleFunction
+  };
+};
+
+// Dynamic date utilities
+export const loadDateUtils = async (): Promise<typeof import('date-fns')> => {
+  const dateFns = await import('date-fns');
+  return dateFns;
+};
+
+// Dynamic chart utilities - using unknown type to avoid Recharts type issues
+export const loadChartUtils = async (): Promise<unknown> => {
+  const recharts = await import('recharts');
+  return recharts;
+};
+
+// Dynamic form utilities
+export const loadFormUtils = async (): Promise<{
+  useForm: unknown;
+  useController: unknown;
+  Controller: unknown;
+  FormProvider: unknown;
+  useFormContext: unknown;
+  useWatch: unknown;
+  useFormState: unknown;
+  useFieldArray: unknown;
+  zodResolver: unknown;
+}> => {
+  const [reactHookForm, zodResolvers] = await Promise.all([
+    import('react-hook-form'),
+    import('@hookform/resolvers/zod')
+  ]);
+  
+  return {
+    ...reactHookForm,
+    zodResolver: zodResolvers.zodResolver
+  };
+};
+
+// Dynamic CSV utilities
+export const loadCSVUtils = async (): Promise<unknown> => {
+  const papaparse = await import('papaparse');
+  return papaparse.default;
+};
+
+// Utility function to create lazy utility hooks
+export function createLazyUtility<T>(loader: () => Promise<T>) {
+  let cached: T | null = null;
+  let loading: Promise<T> | null = null;
+
+  return {
+    load: async (): Promise<T> => {
+      if (cached) return cached;
+      if (loading) return loading;
+
+      loading = loader().then(result => {
+        cached = result;
+        loading = null;
+        return result;
+      });
+
+      return loading;
+    },
+    getCached: (): T | null => cached,
+    isLoaded: (): boolean => cached !== null
+  };
+}
+
+// Pre-configured lazy utilities with explicit types
+export const lazyLodash: ReturnType<typeof createLazyUtility<Awaited<ReturnType<typeof loadLodash>>>> = createLazyUtility(loadLodash);
+export const lazyDateUtils: ReturnType<typeof createLazyUtility<Awaited<ReturnType<typeof loadDateUtils>>>> = createLazyUtility(loadDateUtils);
+export const lazyChartUtils: ReturnType<typeof createLazyUtility<unknown>> = createLazyUtility(loadChartUtils);
+export const lazyFormUtils: ReturnType<typeof createLazyUtility<Awaited<ReturnType<typeof loadFormUtils>>>> = createLazyUtility(loadFormUtils);
+export const lazyCSVUtils: ReturnType<typeof createLazyUtility<unknown>> = createLazyUtility(loadCSVUtils);