@sc4rfurryx/proteusjs 1.0.0

package/src/performance/CacheOptimizationSystem.ts

@@ -0,0 +1,601 @@
+/**
+ * Cache Optimization System for ProteusJS
+ * Intelligent caching with memory pressure-based eviction
+ */
+
+export interface CacheConfig {
+  maxSize: number;
+  maxAge: number;
+  memoryThreshold: number;
+  evictionStrategy: 'lru' | 'lfu' | 'ttl' | 'adaptive';
+  compressionEnabled: boolean;
+  persistentStorage: boolean;
+  storageKey: string;
+}
+
+export interface CacheEntry<T> {
+  key: string;
+  value: T;
+  timestamp: number;
+  lastAccessed: number;
+  accessCount: number;
+  size: number;
+  ttl?: number;
+  compressed?: boolean;
+}
+
+export interface CacheMetrics {
+  totalEntries: number;
+  totalSize: number;
+  hitRate: number;
+  missRate: number;
+  evictions: number;
+  compressionRatio: number;
+}
+
+export class CacheOptimizationSystem<T = any> {
+  private config: Required<CacheConfig>;
+  private cache: Map<string, CacheEntry<T>> = new Map();
+  private accessOrder: string[] = [];
+  private metrics: CacheMetrics;
+  private cleanupTimer: number | null = null;
+
+  constructor(config: Partial<CacheConfig> = {}) {
+    this.config = {
+      maxSize: 100,
+      maxAge: 300000, // 5 minutes
+      memoryThreshold: 10 * 1024 * 1024, // 10MB
+      evictionStrategy: 'adaptive',
+      compressionEnabled: true,
+      persistentStorage: false,
+      storageKey: 'proteus-cache',
+      ...config
+    };
+
+    this.metrics = this.createInitialMetrics();
+    this.loadFromStorage();
+    this.startCleanupTimer();
+  }
+
+  /**
+   * Get value from cache
+   */
+  public get(key: string): T | null {
+    const entry = this.cache.get(key);
+    
+    if (!entry) {
+      this.metrics.missRate++;
+      return null;
+    }
+
+    // Check TTL
+    if (entry.ttl && Date.now() > entry.timestamp + entry.ttl) {
+      this.delete(key);
+      this.metrics.missRate++;
+      return null;
+    }
+
+    // Update access info
+    entry.lastAccessed = Date.now();
+    entry.accessCount++;
+    this.updateAccessOrder(key);
+    
+    this.metrics.hitRate++;
+    
+    // Decompress if needed
+    let value = entry.value;
+    if (entry.compressed && this.config.compressionEnabled) {
+      value = this.decompress(value);
+    }
+    
+    return value;
+  }
+
+  /**
+   * Set value in cache
+   */
+  public set(key: string, value: T, ttl?: number): void {
+    // Check if we need to evict entries
+    if (this.cache.size >= this.config.maxSize) {
+      this.evictEntries(1);
+    }
+
+    // Compress value if enabled
+    let finalValue = value;
+    let compressed = false;
+    if (this.config.compressionEnabled && this.shouldCompress(value)) {
+      finalValue = this.compress(value);
+      compressed = true;
+    }
+
+    const size = this.calculateSize(finalValue);
+    const entry: CacheEntry<T> = {
+      key,
+      value: finalValue,
+      timestamp: Date.now(),
+      lastAccessed: Date.now(),
+      accessCount: 1,
+      size,
+      ...(ttl !== undefined && { ttl }),
+      compressed
+    };
+
+    // Remove existing entry if it exists
+    if (this.cache.has(key)) {
+      this.delete(key);
+    }
+
+    this.cache.set(key, entry);
+    this.updateAccessOrder(key);
+    this.updateMetrics();
+
+    // Check memory pressure
+    this.checkMemoryPressure();
+  }
+
+  /**
+   * Delete entry from cache
+   */
+  public delete(key: string): boolean {
+    const deleted = this.cache.delete(key);
+    if (deleted) {
+      this.removeFromAccessOrder(key);
+      this.updateMetrics();
+    }
+    return deleted;
+  }
+
+  /**
+   * Check if key exists in cache
+   */
+  public has(key: string): boolean {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+
+    // Check TTL
+    if (entry.ttl && Date.now() > entry.timestamp + entry.ttl) {
+      this.delete(key);
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Clear all cache entries
+   */
+  public clear(): void {
+    this.cache.clear();
+    this.accessOrder = [];
+    this.updateMetrics();
+  }
+
+  /**
+   * Get cache metrics
+   */
+  public getMetrics(): CacheMetrics {
+    return { ...this.metrics };
+  }
+
+  /**
+   * Cache calculation result with automatic key generation
+   */
+  public cacheCalculation<R>(
+    fn: () => R,
+    keyParts: (string | number)[],
+    ttl?: number
+  ): R {
+    const key = this.generateKey('calc', keyParts);
+    
+    let result = this.get(key) as R;
+    if (result === null) {
+      result = fn();
+      this.set(key, result as unknown as T, ttl);
+    }
+    
+    return result;
+  }
+
+  /**
+   * Cache layout measurement
+   */
+  public cacheLayoutMeasurement(
+    element: Element,
+    measurement: () => DOMRect | number,
+    ttl: number = 1000 // Short TTL for layout measurements
+  ): DOMRect | number {
+    const key = this.generateKey('layout', [
+      element.tagName,
+      element.className,
+      element.id || 'no-id'
+    ]);
+    
+    let result = this.get(key) as DOMRect | number;
+    if (result === null) {
+      result = measurement();
+      this.set(key, result as unknown as T, ttl);
+    }
+    
+    return result;
+  }
+
+  /**
+   * Cache container state
+   */
+  public cacheContainerState(
+    containerId: string,
+    state: any,
+    ttl: number = 5000
+  ): void {
+    const key = this.generateKey('container', [containerId]);
+    this.set(key, state, ttl);
+  }
+
+  /**
+   * Get cached container state
+   */
+  public getCachedContainerState(containerId: string): any {
+    const key = this.generateKey('container', [containerId]);
+    return this.get(key);
+  }
+
+  /**
+   * Cache computed styles
+   */
+  public cacheComputedStyles(
+    element: Element,
+    properties: string[],
+    ttl: number = 2000
+  ): CSSStyleDeclaration | null {
+    const key = this.generateKey('styles', [
+      element.tagName,
+      element.className,
+      properties.join(',')
+    ]);
+    
+    let styles = this.get(key) as CSSStyleDeclaration;
+    if (styles === null) {
+      styles = window.getComputedStyle(element);
+      // Create a plain object to avoid caching live CSSStyleDeclaration
+      const stylesObj: Record<string, string> = {};
+      properties.forEach(prop => {
+        stylesObj[prop] = styles.getPropertyValue(prop);
+      });
+      this.set(key, stylesObj as any, ttl);
+      return stylesObj as any;
+    }
+    
+    return styles;
+  }
+
+  /**
+   * Optimize cache based on memory pressure
+   */
+  public optimize(): void {
+    // Remove expired entries
+    this.removeExpiredEntries();
+    
+    // Check memory pressure and evict if needed
+    this.checkMemoryPressure();
+    
+    // Compress large entries
+    this.compressLargeEntries();
+    
+    // Update metrics
+    this.updateMetrics();
+  }
+
+  /**
+   * Destroy cache system
+   */
+  public destroy(): void {
+    this.stopCleanupTimer();
+    this.saveToStorage();
+    this.clear();
+  }
+
+  /**
+   * Evict entries based on strategy
+   */
+  private evictEntries(count: number): void {
+    const strategy = this.config.evictionStrategy;
+    let keysToEvict: string[] = [];
+
+    switch (strategy) {
+      case 'lru':
+        keysToEvict = this.getLRUKeys(count);
+        break;
+      case 'lfu':
+        keysToEvict = this.getLFUKeys(count);
+        break;
+      case 'ttl':
+        keysToEvict = this.getTTLKeys(count);
+        break;
+      case 'adaptive':
+        keysToEvict = this.getAdaptiveKeys(count);
+        break;
+    }
+
+    keysToEvict.forEach(key => {
+      this.delete(key);
+      this.metrics.evictions++;
+    });
+  }
+
+  /**
+   * Get LRU (Least Recently Used) keys
+   */
+  private getLRUKeys(count: number): string[] {
+    return this.accessOrder.slice(0, count);
+  }
+
+  /**
+   * Get LFU (Least Frequently Used) keys
+   */
+  private getLFUKeys(count: number): string[] {
+    const entries = Array.from(this.cache.entries());
+    entries.sort((a, b) => a[1].accessCount - b[1].accessCount);
+    return entries.slice(0, count).map(([key]) => key);
+  }
+
+  /**
+   * Get TTL-based keys (oldest first)
+   */
+  private getTTLKeys(count: number): string[] {
+    const entries = Array.from(this.cache.entries());
+    entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
+    return entries.slice(0, count).map(([key]) => key);
+  }
+
+  /**
+   * Get adaptive eviction keys (combination of strategies)
+   */
+  private getAdaptiveKeys(count: number): string[] {
+    const entries = Array.from(this.cache.entries());
+    
+    // Score based on age, access frequency, and size
+    entries.forEach(([key, entry]) => {
+      const age = Date.now() - entry.lastAccessed;
+      const frequency = entry.accessCount;
+      const size = entry.size;
+      
+      // Lower score = higher priority for eviction
+      (entry as any).score = (age / 1000) + (size / 1024) - (frequency * 10);
+    });
+    
+    entries.sort((a, b) => (b[1] as any).score - (a[1] as any).score);
+    return entries.slice(0, count).map(([key]) => key);
+  }
+
+  /**
+   * Check memory pressure and evict if needed
+   */
+  private checkMemoryPressure(): void {
+    const totalSize = this.getTotalSize();
+    
+    if (totalSize > this.config.memoryThreshold) {
+      const evictCount = Math.ceil(this.cache.size * 0.2); // Evict 20%
+      this.evictEntries(evictCount);
+    }
+  }
+
+  /**
+   * Remove expired entries
+   */
+  private removeExpiredEntries(): void {
+    const now = Date.now();
+    const expiredKeys: string[] = [];
+
+    this.cache.forEach((entry, key) => {
+      const isExpired = entry.ttl 
+        ? now > entry.timestamp + entry.ttl
+        : now > entry.timestamp + this.config.maxAge;
+      
+      if (isExpired) {
+        expiredKeys.push(key);
+      }
+    });
+
+    expiredKeys.forEach(key => this.delete(key));
+  }
+
+  /**
+   * Compress large entries
+   */
+  private compressLargeEntries(): void {
+    if (!this.config.compressionEnabled) return;
+
+    this.cache.forEach((entry, key) => {
+      if (!entry.compressed && entry.size > 1024) { // 1KB threshold
+        const compressed = this.compress(entry.value);
+        const compressedSize = this.calculateSize(compressed);
+        
+        if (compressedSize < entry.size * 0.8) { // Only if 20% reduction
+          entry.value = compressed;
+          entry.size = compressedSize;
+          entry.compressed = true;
+        }
+      }
+    });
+  }
+
+  /**
+   * Update access order for LRU
+   */
+  private updateAccessOrder(key: string): void {
+    this.removeFromAccessOrder(key);
+    this.accessOrder.push(key);
+  }
+
+  /**
+   * Remove key from access order
+   */
+  private removeFromAccessOrder(key: string): void {
+    const index = this.accessOrder.indexOf(key);
+    if (index > -1) {
+      this.accessOrder.splice(index, 1);
+    }
+  }
+
+  /**
+   * Generate cache key
+   */
+  private generateKey(prefix: string, parts: (string | number)[]): string {
+    return `${prefix}:${parts.join(':')}`;
+  }
+
+  /**
+   * Calculate size of value
+   */
+  private calculateSize(value: any): number {
+    if (typeof value === 'string') {
+      return value.length * 2; // Approximate UTF-16 size
+    }
+    
+    try {
+      return JSON.stringify(value).length * 2;
+    } catch {
+      return 1024; // Default estimate
+    }
+  }
+
+  /**
+   * Get total cache size
+   */
+  private getTotalSize(): number {
+    let total = 0;
+    this.cache.forEach(entry => {
+      total += entry.size;
+    });
+    return total;
+  }
+
+  /**
+   * Check if value should be compressed
+   */
+  private shouldCompress(value: any): boolean {
+    const size = this.calculateSize(value);
+    return size > 512; // Compress values larger than 512 bytes
+  }
+
+  /**
+   * Compress value (simple implementation)
+   */
+  private compress(value: any): any {
+    // In a real implementation, you might use a compression library
+    // For now, we'll just stringify and indicate it's compressed
+    return {
+      __compressed: true,
+      data: JSON.stringify(value)
+    };
+  }
+
+  /**
+   * Decompress value
+   */
+  private decompress(value: any): any {
+    if (value && value.__compressed) {
+      return JSON.parse(value.data);
+    }
+    return value;
+  }
+
+  /**
+   * Update cache metrics
+   */
+  private updateMetrics(): void {
+    this.metrics.totalEntries = this.cache.size;
+    this.metrics.totalSize = this.getTotalSize();
+
+    const totalRequests = this.metrics.hitRate + this.metrics.missRate;
+    if (totalRequests > 0) {
+      this.metrics.hitRate = this.metrics.hitRate / totalRequests;
+      this.metrics.missRate = this.metrics.missRate / totalRequests;
+    }
+
+    // Calculate compression ratio
+    let totalOriginalSize = 0;
+    let totalCompressedSize = 0;
+    let compressedCount = 0;
+
+    this.cache.forEach(entry => {
+      if (entry.compressed) {
+        compressedCount++;
+        totalCompressedSize += entry.size;
+        // Estimate original size (compressed data is typically 30-70% of original)
+        totalOriginalSize += entry.size / 0.5; // Assume 50% compression
+      }
+    });
+
+    if (compressedCount > 0 && totalOriginalSize > 0) {
+      this.metrics.compressionRatio = totalCompressedSize / totalOriginalSize;
+    }
+  }
+
+  /**
+   * Start cleanup timer
+   */
+  private startCleanupTimer(): void {
+    this.cleanupTimer = window.setInterval(() => {
+      this.optimize();
+    }, 30000); // Cleanup every 30 seconds
+  }
+
+  /**
+   * Stop cleanup timer
+   */
+  private stopCleanupTimer(): void {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+
+  /**
+   * Load cache from persistent storage
+   */
+  private loadFromStorage(): void {
+    if (!this.config.persistentStorage) return;
+
+    try {
+      const stored = localStorage.getItem(this.config.storageKey);
+      if (stored) {
+        const data = JSON.parse(stored);
+        data.forEach((entry: CacheEntry<T>) => {
+          this.cache.set(entry.key, entry);
+          this.accessOrder.push(entry.key);
+        });
+      }
+    } catch (error) {
+      console.warn('Failed to load cache from storage:', error);
+    }
+  }
+
+  /**
+   * Save cache to persistent storage
+   */
+  private saveToStorage(): void {
+    if (!this.config.persistentStorage) return;
+
+    try {
+      const data = Array.from(this.cache.values());
+      localStorage.setItem(this.config.storageKey, JSON.stringify(data));
+    } catch (error) {
+      console.warn('Failed to save cache to storage:', error);
+    }
+  }
+
+  /**
+   * Create initial metrics
+   */
+  private createInitialMetrics(): CacheMetrics {
+    return {
+      totalEntries: 0,
+      totalSize: 0,
+      hitRate: 0,
+      missRate: 0,
+      evictions: 0,
+      compressionRatio: 0
+    };
+  }
+}