@tachui/core 0.7.0-alpha1 → 0.7.1-alpha

package/src/validation/performance-optimizer.ts

@@ -1,599 +0,0 @@
-/**
- * Performance Optimization System - Phase 1C
- * 
- * Advanced performance optimizations to reduce validation overhead
- * to <5% impact in development mode with smart caching and batching.
- */
-
-import { ProductionModeManager } from './production-bypass'
-import { validationDebugger } from './debug-tools'
-
-/**
- * Performance optimization configuration
- */
-export interface PerformanceOptimizerConfig {
-  enabled: boolean
-  targetOverhead: number // percentage (5 = 5%)
-  batchSize: number
-  cacheStrategy: 'aggressive' | 'moderate' | 'conservative'
-  asyncValidation: boolean
-  throttleMs: number
-  skipFrames: number // Skip validation every N frames
-}
-
-/**
- * Validation operation metrics
- */
-export interface ValidationMetrics {
-  operationCount: number
-  totalTime: number
-  averageTime: number
-  maxTime: number
-  cacheHitRate: number
-  skipRate: number
-}
-
-/**
- * Performance optimization engine
- */
-export class PerformanceOptimizer {
-  private static instance: PerformanceOptimizer
-  private config: PerformanceOptimizerConfig
-  private metrics = new Map<string, ValidationMetrics>()
-  private operationQueue: Array<() => void> = []
-  private frameCounter = 0
-  private lastBatchTime = 0
-  private throttleTimers = new Map<string, number>()
-  
-  // Advanced caching
-  private resultCache = new Map<string, { result: any; timestamp: number; hits: number }>()
-  
-  // Performance monitoring
-  private performanceObserver?: PerformanceObserver
-  private frameTimeTarget = 16.67 // 60fps target
-
-  constructor(config: Partial<PerformanceOptimizerConfig> = {}) {
-    this.config = {
-      enabled: process.env.NODE_ENV !== 'production',
-      targetOverhead: 5, // 5% overhead target
-      batchSize: 10,
-      cacheStrategy: 'moderate',
-      asyncValidation: true,
-      throttleMs: 16, // One frame
-      skipFrames: 0, // Don't skip by default
-      ...config
-    }
-
-    this.initializePerformanceMonitoring()
-  }
-
-  static getInstance(config?: Partial<PerformanceOptimizerConfig>): PerformanceOptimizer {
-    if (!this.instance) {
-      this.instance = new PerformanceOptimizer(config)
-    }
-    return this.instance
-  }
-
-  /**
-   * Optimize validation function with caching and batching
-   */
-  optimizeValidation<T>(
-    key: string,
-    validationFn: () => T,
-    options: {
-      cache?: boolean
-      batch?: boolean
-      throttle?: boolean
-      priority?: 'high' | 'medium' | 'low'
-    } = {}
-  ): T | Promise<T> {
-    // Skip optimization in production
-    if (ProductionModeManager.shouldBypassValidation()) {
-      return validationFn()
-    }
-
-    const {
-      cache = true,
-      batch = false,
-      throttle = false,
-      priority = 'medium'
-    } = options
-
-    // Check cache first
-    if (cache) {
-      const cached = this.getCachedResult(key)
-      if (cached !== undefined) {
-        this.updateMetrics(key, 0, true, false) // Cache hit
-        return cached
-      }
-    }
-
-    // Apply frame skipping if configured
-    if (this.shouldSkipFrame()) {
-      this.updateMetrics(key, 0, false, true) // Skipped
-      return this.getFallbackResult()
-    }
-
-    // Apply throttling
-    if (throttle && this.isThrottled(key)) {
-      return this.getFallbackResult()
-    }
-
-    const startTime = performance.now()
-
-    try {
-      let result: T
-
-      if (batch && priority !== 'high') {
-        // Add to batch queue for low priority operations
-        return this.addToBatch(key, validationFn, cache) as Promise<T>
-      } else {
-        // Execute immediately
-        result = validationFn()
-      }
-
-      const endTime = performance.now()
-      const duration = endTime - startTime
-
-      // Cache result if enabled
-      if (cache) {
-        this.cacheResult(key, result)
-      }
-
-      // Update metrics
-      this.updateMetrics(key, duration, false, false)
-
-      // Check performance impact
-      this.checkPerformanceImpact(duration)
-
-      return result
-
-    } catch (error) {
-      const endTime = performance.now()
-      this.updateMetrics(key, endTime - startTime, false, false)
-      throw error
-    }
-  }
-
-  /**
-   * Smart caching with TTL and popularity-based eviction
-   */
-  private getCachedResult(key: string): any {
-    const cached = this.resultCache.get(key)
-    if (!cached) return undefined
-
-    // Check TTL based on cache strategy
-    const ttl = this.getCacheTTL()
-    if (Date.now() - cached.timestamp > ttl) {
-      this.resultCache.delete(key)
-      return undefined
-    }
-
-    // Update hit count
-    cached.hits++
-    return cached.result
-  }
-
-  /**
-   * Cache result with intelligent eviction
-   */
-  private cacheResult(key: string, result: any): void {
-    const maxCacheSize = this.getMaxCacheSize()
-    
-    // Evict least popular entries if cache is full
-    if (this.resultCache.size >= maxCacheSize) {
-      this.evictLeastPopular()
-    }
-
-    this.resultCache.set(key, {
-      result,
-      timestamp: Date.now(),
-      hits: 1
-    })
-  }
-
-  /**
-   * Evict least popular cache entries
-   */
-  private evictLeastPopular(): void {
-    const entries = Array.from(this.resultCache.entries())
-    
-    // Sort by hits (ascending) and timestamp (ascending)
-    entries.sort((a, b) => {
-      if (a[1].hits !== b[1].hits) {
-        return a[1].hits - b[1].hits
-      }
-      return a[1].timestamp - b[1].timestamp
-    })
-
-    // Remove bottom 25%
-    const removeCount = Math.floor(entries.length * 0.25)
-    for (let i = 0; i < removeCount; i++) {
-      this.resultCache.delete(entries[i][0])
-    }
-  }
-
-  /**
-   * Get cache TTL based on strategy
-   */
-  private getCacheTTL(): number {
-    switch (this.config.cacheStrategy) {
-      case 'aggressive': return 300000 // 5 minutes
-      case 'moderate': return 60000   // 1 minute
-      case 'conservative': return 10000 // 10 seconds
-      default: return 60000
-    }
-  }
-
-  /**
-   * Get max cache size based on strategy
-   */
-  private getMaxCacheSize(): number {
-    switch (this.config.cacheStrategy) {
-      case 'aggressive': return 1000
-      case 'moderate': return 500
-      case 'conservative': return 100
-      default: return 500
-    }
-  }
-
-  /**
-   * Check if operation should skip this frame
-   */
-  private shouldSkipFrame(): boolean {
-    if (this.config.skipFrames === 0) return false
-    
-    this.frameCounter++
-    return this.frameCounter % (this.config.skipFrames + 1) !== 0
-  }
-
-  /**
-   * Check if operation is throttled
-   */
-  private isThrottled(key: string): boolean {
-    const lastTime = this.throttleTimers.get(key) || 0
-    const now = Date.now()
-    
-    if (now - lastTime < this.config.throttleMs) {
-      return true
-    }
-    
-    this.throttleTimers.set(key, now)
-    return false
-  }
-
-  /**
-   * Add operation to batch queue
-   */
-  private addToBatch<T>(key: string, fn: () => T, cache: boolean): Promise<T> {
-    return new Promise((resolve, reject) => {
-      this.operationQueue.push(() => {
-        try {
-          const result = fn()
-          if (cache) {
-            this.cacheResult(key, result)
-          }
-          resolve(result)
-        } catch (error) {
-          reject(error)
-        }
-      })
-
-      // Process batch if it's full or enough time has passed
-      this.processBatchIfReady()
-    })
-  }
-
-  /**
-   * Process batch queue if conditions are met
-   */
-  private processBatchIfReady(): void {
-    const now = Date.now()
-    const shouldProcess = 
-      this.operationQueue.length >= this.config.batchSize ||
-      (this.operationQueue.length > 0 && now - this.lastBatchTime > this.config.throttleMs)
-
-    if (shouldProcess) {
-      this.processBatch()
-    }
-  }
-
-  /**
-   * Process batch queue
-   */
-  private processBatch(): void {
-    if (this.operationQueue.length === 0) return
-
-    const batch = this.operationQueue.splice(0, this.config.batchSize)
-    this.lastBatchTime = Date.now()
-
-    if (this.config.asyncValidation) {
-      // Process asynchronously to not block the main thread
-      setTimeout(() => {
-        batch.forEach(operation => operation())
-      }, 0)
-    } else {
-      // Process synchronously
-      batch.forEach(operation => operation())
-    }
-  }
-
-  /**
-   * Update operation metrics
-   */
-  private updateMetrics(key: string, duration: number, cacheHit: boolean, skipped: boolean): void {
-    let metrics = this.metrics.get(key)
-    if (!metrics) {
-      metrics = {
-        operationCount: 0,
-        totalTime: 0,
-        averageTime: 0,
-        maxTime: 0,
-        cacheHitRate: 0,
-        skipRate: 0
-      }
-      this.metrics.set(key, metrics)
-    }
-
-    metrics.operationCount++
-    
-    if (!cacheHit && !skipped) {
-      metrics.totalTime += duration
-      metrics.averageTime = metrics.totalTime / metrics.operationCount
-      metrics.maxTime = Math.max(metrics.maxTime, duration)
-    }
-
-    // Update rates
-    const totalOperations = metrics.operationCount
-    const cacheHits = Math.floor(metrics.cacheHitRate * totalOperations) + (cacheHit ? 1 : 0)
-    const skips = Math.floor(metrics.skipRate * totalOperations) + (skipped ? 1 : 0)
-    
-    metrics.cacheHitRate = cacheHits / totalOperations
-    metrics.skipRate = skips / totalOperations
-  }
-
-  /**
-   * Check if performance impact exceeds target
-   */
-  private checkPerformanceImpact(duration: number): void {
-    const frameTime = this.frameTimeTarget
-    const impactPercentage = (duration / frameTime) * 100
-
-    if (impactPercentage > this.config.targetOverhead) {
-      // Automatically adjust optimization settings
-      this.autoOptimize(impactPercentage)
-      
-      validationDebugger.logEvent(
-        'performance-warning',
-        `Validation overhead: ${impactPercentage.toFixed(1)}% (target: ${this.config.targetOverhead}%)`,
-        { duration, target: this.config.targetOverhead, actual: impactPercentage }
-      )
-    }
-  }
-
-  /**
-   * Automatically adjust optimization settings
-   */
-  private autoOptimize(currentImpact: number): void {
-    const factor = currentImpact / this.config.targetOverhead
-
-    if (factor > 2) {
-      // Very high impact - aggressive optimization
-      this.config.cacheStrategy = 'aggressive'
-      this.config.skipFrames = Math.max(1, this.config.skipFrames)
-      this.config.throttleMs = Math.max(this.config.throttleMs, 32)
-      this.config.batchSize = Math.min(this.config.batchSize, 5)
-    } else if (factor > 1.5) {
-      // High impact - moderate optimization
-      this.config.cacheStrategy = 'aggressive'
-      this.config.throttleMs = Math.max(this.config.throttleMs, 16)
-    }
-  }
-
-  /**
-   * Get fallback result for skipped/throttled operations
-   */
-  private getFallbackResult(): any {
-    // Return a safe default that won't cause errors
-    // In practice, this would be context-specific
-    return true
-  }
-
-  /**
-   * Initialize performance monitoring
-   */
-  private initializePerformanceMonitoring(): void {
-    if (typeof PerformanceObserver !== 'undefined') {
-      try {
-        this.performanceObserver = new PerformanceObserver((list) => {
-          const entries = list.getEntries()
-          entries.forEach((entry) => {
-            if (entry.name.includes('tachui-validation')) {
-              this.analyzePerformanceEntry(entry)
-            }
-          })
-        })
-        
-        this.performanceObserver.observe({ entryTypes: ['measure', 'navigation', 'paint'] })
-      } catch (_error) {
-        // PerformanceObserver not supported
-      }
-    }
-  }
-
-  /**
-   * Analyze performance entry
-   */
-  private analyzePerformanceEntry(entry: PerformanceEntry): void {
-    if (entry.duration > this.frameTimeTarget) {
-      console.warn(`⚠️ Slow validation operation: ${entry.name} took ${entry.duration.toFixed(2)}ms`)
-    }
-  }
-
-  /**
-   * Get performance statistics
-   */
-  getPerformanceStats() {
-    const totalOperations = Array.from(this.metrics.values())
-      .reduce((sum, metrics) => sum + metrics.operationCount, 0)
-    
-    const totalTime = Array.from(this.metrics.values())
-      .reduce((sum, metrics) => sum + metrics.totalTime, 0)
-    
-    const averageTime = totalOperations > 0 ? totalTime / totalOperations : 0
-    
-    const cacheHitRate = Array.from(this.metrics.values())
-      .reduce((sum, metrics) => sum + metrics.cacheHitRate, 0) / this.metrics.size || 0
-    
-    const skipRate = Array.from(this.metrics.values())
-      .reduce((sum, metrics) => sum + metrics.skipRate, 0) / this.metrics.size || 0
-
-    return {
-      config: this.config,
-      totalOperations,
-      totalTime,
-      averageTime,
-      cacheHitRate,
-      skipRate,
-      cacheSize: this.resultCache.size,
-      queueSize: this.operationQueue.length,
-      frameImpact: (averageTime / this.frameTimeTarget) * 100,
-      targetMet: (averageTime / this.frameTimeTarget) * 100 <= this.config.targetOverhead,
-      operations: Object.fromEntries(this.metrics)
-    }
-  }
-
-  /**
-   * Clear all caches and reset metrics
-   */
-  reset(): void {
-    this.resultCache.clear()
-    this.metrics.clear()
-    this.operationQueue = []
-    this.throttleTimers.clear()
-    this.frameCounter = 0
-    this.lastBatchTime = 0
-  }
-
-  /**
-   * Configure optimizer
-   */
-  configure(config: Partial<PerformanceOptimizerConfig>): void {
-    this.config = { ...this.config, ...config }
-  }
-
-  /**
-   * Force process all batched operations
-   */
-  flush(): void {
-    while (this.operationQueue.length > 0) {
-      this.processBatch()
-    }
-  }
-
-  /**
-   * Get cache statistics
-   */
-  getCacheStats() {
-    const entries = Array.from(this.resultCache.values())
-    const totalHits = entries.reduce((sum, entry) => sum + entry.hits, 0)
-    const averageAge = entries.length > 0 
-      ? entries.reduce((sum, entry) => sum + (Date.now() - entry.timestamp), 0) / entries.length
-      : 0
-
-    return {
-      size: this.resultCache.size,
-      maxSize: this.getMaxCacheSize(),
-      totalHits,
-      averageAge,
-      strategy: this.config.cacheStrategy,
-      ttl: this.getCacheTTL()
-    }
-  }
-}
-
-// Global optimizer instance
-export const performanceOptimizer = PerformanceOptimizer.getInstance()
-
-// Performance optimization utilities
-export const PerformanceOptimizationUtils = {
-  /**
-   * Configure performance optimizer
-   */
-  configure: (config: Partial<PerformanceOptimizerConfig>) => 
-    performanceOptimizer.configure(config),
-
-  /**
-   * Get performance statistics
-   */
-  getStats: () => performanceOptimizer.getPerformanceStats(),
-
-  /**
-   * Get cache statistics
-   */
-  getCacheStats: () => performanceOptimizer.getCacheStats(),
-
-  /**
-   * Reset optimizer
-   */
-  reset: () => performanceOptimizer.reset(),
-
-  /**
-   * Flush batched operations
-   */
-  flush: () => performanceOptimizer.flush(),
-
-  /**
-   * Optimize validation function
-   */
-  optimize: <T>(
-    key: string,
-    fn: () => T,
-    options?: {
-      cache?: boolean
-      batch?: boolean
-      throttle?: boolean
-      priority?: 'high' | 'medium' | 'low'
-    }
-  ) => performanceOptimizer.optimizeValidation(key, fn, options),
-
-  /**
-   * Test performance optimization
-   */
-  test: () => {
-    console.group('⚡ Performance Optimization Test')
-    
-    try {
-      const startTime = performance.now()
-      
-      // Test optimization with different scenarios
-      const results = []
-      
-      // Test caching
-      for (let i = 0; i < 100; i++) {
-        const result = performanceOptimizer.optimizeValidation(
-          'test-cache',
-          () => Math.random(),
-          { cache: true }
-        )
-        results.push(result)
-      }
-      
-      const endTime = performance.now()
-      const duration = endTime - startTime
-      const stats = performanceOptimizer.getPerformanceStats()
-      
-      console.info('✅ Optimization system active:', stats.config.enabled)
-      console.info('✅ Test duration:', `${duration.toFixed(2)}ms`)
-      console.info('✅ Cache hit rate:', `${(stats.cacheHitRate * 100).toFixed(1)}%`)
-      console.info('✅ Frame impact:', `${stats.frameImpact.toFixed(1)}% (target: ${stats.config.targetOverhead}%)`)
-      console.info('✅ Target met:', stats.targetMet)
-      console.info('✅ Performance optimization is working correctly')
-      
-    } catch (error) {
-      console.error('❌ Performance optimization test failed:', error)
-    }
-    
-    console.groupEnd()
-  }
-}