@sc4rfurryx/proteusjs 1.0.0

package/src/performance/MemoryManagementSystem.ts

@@ -0,0 +1,497 @@
+/**
+ * Memory Management System for ProteusJS
+ * Automatic observer cleanup, event listener lifecycle management, and memory optimization
+ */
+
+export interface MemoryConfig {
+  autoCleanup: boolean;
+  cleanupInterval: number;
+  memoryThreshold: number;
+  gcOptimization: boolean;
+  leakDetection: boolean;
+  performanceMonitoring: boolean;
+}
+
+export interface MemoryMetrics {
+  totalObservers: number;
+  activeObservers: number;
+  totalEventListeners: number;
+  activeEventListeners: number;
+  memoryUsage: number;
+  gcCollections: number;
+  leaksDetected: number;
+  cleanupOperations: number;
+}
+
+export interface ManagedResource {
+  id: string;
+  type: 'observer' | 'listener' | 'timer' | 'animation' | 'cache';
+  element?: Element;
+  cleanup: () => void;
+  timestamp: number;
+  lastAccessed: number;
+  memorySize: number;
+}
+
+export class MemoryManagementSystem {
+  private config: Required<MemoryConfig>;
+  private resources: Map<string, ManagedResource> = new Map();
+  private metrics: MemoryMetrics;
+  private cleanupTimer: number | null = null;
+  private performanceObserver: PerformanceObserver | null = null;
+  private weakRefs: Set<WeakRef<any>> = new Set();
+
+  constructor(config: Partial<MemoryConfig> = {}) {
+    this.config = {
+      autoCleanup: true,
+      cleanupInterval: 30000, // 30 seconds
+      memoryThreshold: 50 * 1024 * 1024, // 50MB
+      gcOptimization: true,
+      leakDetection: true,
+      performanceMonitoring: true,
+      ...config
+    };
+
+    this.metrics = this.createInitialMetrics();
+    this.setupMemoryMonitoring();
+    this.startAutoCleanup();
+  }
+
+  /**
+   * Register a managed resource
+   */
+  public register(
+    type: ManagedResource['type'],
+    cleanup: () => void,
+    element?: Element,
+    estimatedSize: number = 1024
+  ): string {
+    const id = this.generateResourceId();
+    const resource: ManagedResource = {
+      id,
+      type,
+      ...(element && { element }),
+      cleanup,
+      timestamp: performance.now(),
+      lastAccessed: performance.now(),
+      memorySize: estimatedSize
+    };
+
+    this.resources.set(id, resource);
+    this.updateMetrics(type, 'register');
+
+    // Create weak reference for leak detection
+    if (element && this.config.leakDetection) {
+      this.weakRefs.add(new WeakRef(element));
+    }
+
+    return id;
+  }
+
+  /**
+   * Unregister and cleanup a resource
+   */
+  public unregister(id: string): void {
+    const resource = this.resources.get(id);
+    if (resource) {
+      try {
+        resource.cleanup();
+        this.updateMetrics(resource.type, 'unregister');
+      } catch (error) {
+        console.error('Error during resource cleanup:', error);
+      }
+      
+      this.resources.delete(id);
+      this.metrics.cleanupOperations++;
+    }
+  }
+
+  /**
+   * Register ResizeObserver with automatic cleanup
+   */
+  public registerResizeObserver(
+    observer: ResizeObserver,
+    elements: Element[]
+  ): string {
+    return this.register(
+      'observer',
+      () => {
+        observer.disconnect();
+      },
+      elements[0],
+      elements.length * 512 // Estimate memory per observed element
+    );
+  }
+
+  /**
+   * Register IntersectionObserver with automatic cleanup
+   */
+  public registerIntersectionObserver(
+    observer: IntersectionObserver,
+    elements: Element[]
+  ): string {
+    return this.register(
+      'observer',
+      () => {
+        observer.disconnect();
+      },
+      elements[0],
+      elements.length * 256
+    );
+  }
+
+  /**
+   * Register event listener with automatic cleanup
+   */
+  public registerEventListener(
+    element: Element,
+    event: string,
+    listener: EventListener,
+    options?: AddEventListenerOptions
+  ): string {
+    return this.register(
+      'listener',
+      () => {
+        element.removeEventListener(event, listener, options);
+      },
+      element,
+      128 // Estimate memory per listener
+    );
+  }
+
+  /**
+   * Register timer with automatic cleanup
+   */
+  public registerTimer(timerId: number, type: 'timeout' | 'interval' = 'timeout'): string {
+    return this.register(
+      'timer',
+      () => {
+        if (type === 'timeout') {
+          clearTimeout(timerId);
+        } else {
+          clearInterval(timerId);
+        }
+      },
+      undefined,
+      64
+    );
+  }
+
+  /**
+   * Register animation with automatic cleanup
+   */
+  public registerAnimation(animation: Animation): string {
+    return this.register(
+      'animation',
+      () => {
+        animation.cancel();
+      },
+      (animation.effect as any)?.target instanceof Element ? (animation.effect as any).target : undefined,
+      256
+    );
+  }
+
+  /**
+   * Register cache entry with automatic cleanup
+   */
+  public registerCacheEntry(
+    cache: Map<any, any> | WeakMap<any, any>,
+    key: any,
+    estimatedSize: number = 1024
+  ): string {
+    return this.register(
+      'cache',
+      () => {
+        cache.delete(key);
+      },
+      undefined,
+      estimatedSize
+    );
+  }
+
+  /**
+   * Force cleanup of all resources
+   */
+  public cleanup(): void {
+    const resourceIds = Array.from(this.resources.keys());
+    resourceIds.forEach(id => this.unregister(id));
+  }
+
+  /**
+   * Cleanup resources by type
+   */
+  public cleanupByType(type: ManagedResource['type']): void {
+    const resourceIds = Array.from(this.resources.entries())
+      .filter(([, resource]) => resource.type === type)
+      .map(([id]) => id);
+    
+    resourceIds.forEach(id => this.unregister(id));
+  }
+
+  /**
+   * Cleanup stale resources
+   */
+  public cleanupStale(maxAge: number = 300000): void { // 5 minutes default
+    const now = performance.now();
+    const staleIds = Array.from(this.resources.entries())
+      .filter(([, resource]) => now - resource.lastAccessed > maxAge)
+      .map(([id]) => id);
+    
+    staleIds.forEach(id => this.unregister(id));
+  }
+
+  /**
+   * Cleanup resources for removed elements
+   */
+  public cleanupOrphanedResources(): void {
+    const orphanedIds: string[] = [];
+    
+    this.resources.forEach((resource, id) => {
+      if (resource.element && !document.contains(resource.element)) {
+        orphanedIds.push(id);
+      }
+    });
+    
+    orphanedIds.forEach(id => this.unregister(id));
+  }
+
+  /**
+   * Get current memory metrics
+   */
+  public getMetrics(): MemoryMetrics {
+    this.updateMemoryUsage();
+    return { ...this.metrics };
+  }
+
+  /**
+   * Get resource count by type
+   */
+  public getResourceCount(type?: ManagedResource['type']): number {
+    if (!type) {
+      return this.resources.size;
+    }
+    
+    return Array.from(this.resources.values())
+      .filter(resource => resource.type === type).length;
+  }
+
+  /**
+   * Check for memory leaks
+   */
+  public detectLeaks(): string[] {
+    const leaks: string[] = [];
+    
+    // Check for orphaned weak references
+    this.weakRefs.forEach(weakRef => {
+      if (weakRef.deref() === undefined) {
+        // Element was garbage collected but we might still have resources
+        this.cleanupOrphanedResources();
+      }
+    });
+    
+    // Check for excessive resource accumulation
+    const resourceCounts = new Map<string, number>();
+    this.resources.forEach(resource => {
+      const count = resourceCounts.get(resource.type) || 0;
+      resourceCounts.set(resource.type, count + 1);
+    });
+    
+    resourceCounts.forEach((count, type) => {
+      const threshold = this.getThresholdForType(type);
+      if (count > threshold) {
+        leaks.push(`Excessive ${type} resources: ${count} (threshold: ${threshold})`);
+      }
+    });
+    
+    this.metrics.leaksDetected = leaks.length;
+    return leaks;
+  }
+
+  /**
+   * Optimize garbage collection
+   */
+  public optimizeGC(): void {
+    if (!this.config.gcOptimization) return;
+    
+    // Force cleanup of stale resources
+    this.cleanupStale();
+    
+    // Clear weak references to collected objects
+    const validWeakRefs = new Set<WeakRef<any>>();
+    this.weakRefs.forEach(weakRef => {
+      if (weakRef.deref() !== undefined) {
+        validWeakRefs.add(weakRef);
+      }
+    });
+    this.weakRefs = validWeakRefs;
+    
+    // Suggest garbage collection if available
+    if ('gc' in window && typeof window.gc === 'function') {
+      window.gc();
+      this.metrics.gcCollections++;
+    }
+  }
+
+  /**
+   * Destroy memory management system
+   */
+  public destroy(): void {
+    this.stopAutoCleanup();
+    this.stopMemoryMonitoring();
+    this.cleanup();
+    this.weakRefs.clear();
+  }
+
+  /**
+   * Setup memory monitoring
+   */
+  private setupMemoryMonitoring(): void {
+    if (!this.config.performanceMonitoring) return;
+    
+    // Monitor memory usage
+    if ('memory' in performance) {
+      setInterval(() => {
+        this.updateMemoryUsage();
+        this.checkMemoryThreshold();
+      }, 5000);
+    }
+    
+    // Monitor performance entries
+    if (window.PerformanceObserver) {
+      try {
+        this.performanceObserver = new PerformanceObserver((list) => {
+          const entries = list.getEntries();
+          entries.forEach(entry => {
+            if (entry.entryType === 'measure' && entry.name.includes('proteus')) {
+              // Track ProteusJS-related performance measures
+            }
+          });
+        });
+        
+        this.performanceObserver.observe({ entryTypes: ['measure', 'navigation'] });
+      } catch (error) {
+        console.warn('PerformanceObserver not fully supported:', error);
+      }
+    }
+  }
+
+  /**
+   * Start automatic cleanup
+   */
+  private startAutoCleanup(): void {
+    if (!this.config.autoCleanup) return;
+    
+    this.cleanupTimer = window.setInterval(() => {
+      this.cleanupStale();
+      this.cleanupOrphanedResources();
+      this.detectLeaks();
+      
+      if (this.config.gcOptimization) {
+        this.optimizeGC();
+      }
+    }, this.config.cleanupInterval);
+  }
+
+  /**
+   * Stop automatic cleanup
+   */
+  private stopAutoCleanup(): void {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+
+  /**
+   * Stop memory monitoring
+   */
+  private stopMemoryMonitoring(): void {
+    if (this.performanceObserver) {
+      this.performanceObserver.disconnect();
+      this.performanceObserver = null;
+    }
+  }
+
+  /**
+   * Update memory usage metrics
+   */
+  private updateMemoryUsage(): void {
+    if ('memory' in performance) {
+      const memory = (performance as any).memory;
+      this.metrics.memoryUsage = memory.usedJSHeapSize || 0;
+    }
+  }
+
+  /**
+   * Check memory threshold and trigger cleanup if needed
+   */
+  private checkMemoryThreshold(): void {
+    if (this.metrics.memoryUsage > this.config.memoryThreshold) {
+      console.warn('Memory threshold exceeded, triggering cleanup');
+      this.cleanupStale(60000); // Cleanup resources older than 1 minute
+      this.optimizeGC();
+    }
+  }
+
+  /**
+   * Update metrics for resource operations
+   */
+  private updateMetrics(type: ManagedResource['type'], operation: 'register' | 'unregister'): void {
+    switch (type) {
+      case 'observer':
+        if (operation === 'register') {
+          this.metrics.totalObservers++;
+          this.metrics.activeObservers++;
+        } else {
+          this.metrics.activeObservers--;
+        }
+        break;
+      case 'listener':
+        if (operation === 'register') {
+          this.metrics.totalEventListeners++;
+          this.metrics.activeEventListeners++;
+        } else {
+          this.metrics.activeEventListeners--;
+        }
+        break;
+    }
+  }
+
+  /**
+   * Get threshold for resource type
+   */
+  private getThresholdForType(type: string): number {
+    const thresholds: Record<string, number> = {
+      observer: 100,
+      listener: 500,
+      timer: 50,
+      animation: 20,
+      cache: 1000
+    };
+
+    return thresholds[type] || 100;
+  }
+
+  /**
+   * Generate unique resource ID
+   */
+  private generateResourceId(): string {
+    return `mem-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+  }
+
+  /**
+   * Create initial metrics
+   */
+  private createInitialMetrics(): MemoryMetrics {
+    return {
+      totalObservers: 0,
+      activeObservers: 0,
+      totalEventListeners: 0,
+      activeEventListeners: 0,
+      memoryUsage: 0,
+      gcCollections: 0,
+      leaksDetected: 0,
+      cleanupOperations: 0
+    };
+  }
+}