@jmruthers/pace-core 0.5.181 → 0.5.183

package/src/utils/auth-utils.ts

@@ -1,96 +0,0 @@
-/**
- * @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

@@ -1,129 +0,0 @@
-
-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/debugLogger.ts

@@ -1,67 +0,0 @@
-/**
- * @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

@@ -1,215 +0,0 @@
-/**
- * @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

@@ -1,105 +0,0 @@
-
-/**
- * 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);