@sc4rfurryx/proteusjs 1.0.0

package/src/core/MemoryManager.ts

@@ -0,0 +1,321 @@
+/**
+ * Memory Manager for ProteusJS
+ * Prevents memory leaks and manages resource cleanup
+ */
+
+export interface ManagedResource {
+  id: string;
+  type: 'observer' | 'listener' | 'timer' | 'animation' | 'cache';
+  cleanup: () => void;
+  element?: Element;
+  timestamp: number;
+}
+
+export class MemoryManager {
+  private resources: Map<string, ManagedResource> = new Map();
+  private elementResources: Map<Element, Set<string>> = new Map();
+  private mutationObserver: MutationObserver | null = null;
+  private cleanupInterval: number | null = null;
+  private isMonitoring: boolean = false;
+
+  constructor() {
+    this.setupDOMObserver();
+    this.startPeriodicCleanup();
+  }
+
+  /**
+   * Register a resource for automatic cleanup
+   */
+  public register(resource: Omit<ManagedResource, 'timestamp'>): string {
+    const fullResource: ManagedResource = {
+      ...resource,
+      timestamp: Date.now()
+    };
+
+    this.resources.set(resource.id, fullResource);
+
+    // Track element-specific resources
+    if (resource.element) {
+      if (!this.elementResources.has(resource.element)) {
+        this.elementResources.set(resource.element, new Set());
+      }
+      this.elementResources.get(resource.element)!.add(resource.id);
+    }
+
+    return resource.id;
+  }
+
+  /**
+   * Unregister and cleanup a resource
+   */
+  public unregister(resourceId: string): boolean {
+    const resource = this.resources.get(resourceId);
+    if (!resource) return false;
+
+    try {
+      resource.cleanup();
+    } catch (error) {
+      console.error(`ProteusJS: Error cleaning up resource ${resourceId}:`, error);
+    }
+
+    this.resources.delete(resourceId);
+
+    // Remove from element tracking
+    if (resource.element) {
+      const elementResources = this.elementResources.get(resource.element);
+      if (elementResources) {
+        elementResources.delete(resourceId);
+        if (elementResources.size === 0) {
+          this.elementResources.delete(resource.element);
+        }
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Cleanup all resources associated with an element
+   */
+  public cleanupElement(element: Element): number {
+    const resourceIds = this.elementResources.get(element);
+    if (!resourceIds) return 0;
+
+    let cleanedCount = 0;
+    resourceIds.forEach(resourceId => {
+      if (this.unregister(resourceId)) {
+        cleanedCount++;
+      }
+    });
+
+    return cleanedCount;
+  }
+
+  /**
+   * Cleanup resources by type
+   */
+  public cleanupByType(type: ManagedResource['type']): number {
+    let cleanedCount = 0;
+    const toCleanup: string[] = [];
+
+    this.resources.forEach((resource, id) => {
+      if (resource.type === type) {
+        toCleanup.push(id);
+      }
+    });
+
+    toCleanup.forEach(id => {
+      if (this.unregister(id)) {
+        cleanedCount++;
+      }
+    });
+
+    return cleanedCount;
+  }
+
+  /**
+   * Cleanup old resources based on age
+   */
+  public cleanupOldResources(maxAge: number = 300000): number { // 5 minutes default
+    let cleanedCount = 0;
+    const now = Date.now();
+    const toCleanup: string[] = [];
+
+    this.resources.forEach((resource, id) => {
+      if (now - resource.timestamp > maxAge) {
+        toCleanup.push(id);
+      }
+    });
+
+    toCleanup.forEach(id => {
+      if (this.unregister(id)) {
+        cleanedCount++;
+      }
+    });
+
+    return cleanedCount;
+  }
+
+  /**
+   * Force garbage collection if available
+   */
+  public forceGarbageCollection(): void {
+    if ('gc' in window && typeof (window as any).gc === 'function') {
+      try {
+        (window as any).gc();
+      } catch (error) {
+        // Ignore errors - gc might not be available
+      }
+    }
+  }
+
+  /**
+   * Get memory usage information
+   */
+  public getMemoryInfo(): object {
+    const info: any = {
+      managedResources: this.resources.size,
+      trackedElements: this.elementResources.size,
+      resourcesByType: {} as Record<string, number>
+    };
+
+    // Count resources by type
+    this.resources.forEach(resource => {
+      info.resourcesByType[resource.type] = (info.resourcesByType[resource.type] || 0) + 1;
+    });
+
+    // Add browser memory info if available
+    if ('memory' in performance) {
+      const memory = (performance as any).memory;
+      info.browserMemory = {
+        usedJSHeapSize: memory.usedJSHeapSize,
+        totalJSHeapSize: memory.totalJSHeapSize,
+        jsHeapSizeLimit: memory.jsHeapSizeLimit
+      };
+    }
+
+    return info;
+  }
+
+  /**
+   * Check for potential memory leaks
+   */
+  public detectLeaks(): string[] {
+    const warnings: string[] = [];
+    const now = Date.now();
+
+    // Check for too many resources
+    if (this.resources.size > 1000) {
+      warnings.push(`High number of managed resources: ${this.resources.size}`);
+    }
+
+    // Check for old resources
+    let oldResourceCount = 0;
+    this.resources.forEach(resource => {
+      if (now - resource.timestamp > 600000) { // 10 minutes
+        oldResourceCount++;
+      }
+    });
+
+    if (oldResourceCount > 50) {
+      warnings.push(`Many old resources detected: ${oldResourceCount}`);
+    }
+
+    // Check for orphaned element resources
+    let orphanedCount = 0;
+    this.elementResources.forEach((resourceIds, element) => {
+      if (!document.contains(element)) {
+        orphanedCount += resourceIds.size;
+      }
+    });
+
+    if (orphanedCount > 0) {
+      warnings.push(`Orphaned element resources detected: ${orphanedCount}`);
+    }
+
+    return warnings;
+  }
+
+  /**
+   * Cleanup all resources and stop monitoring
+   */
+  public destroy(): void {
+    // Cleanup all resources
+    const resourceIds = Array.from(this.resources.keys());
+    resourceIds.forEach(id => this.unregister(id));
+
+    // Stop monitoring
+    this.stopMonitoring();
+
+    // Clear maps
+    this.resources.clear();
+    this.elementResources.clear();
+  }
+
+  /**
+   * Start monitoring for memory leaks
+   */
+  public startMonitoring(): void {
+    if (this.isMonitoring) return;
+    this.isMonitoring = true;
+  }
+
+  /**
+   * Stop monitoring
+   */
+  public stopMonitoring(): void {
+    if (!this.isMonitoring) return;
+
+    this.isMonitoring = false;
+
+    if (this.mutationObserver) {
+      this.mutationObserver.disconnect();
+      this.mutationObserver = null;
+    }
+
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+
+  /**
+   * Setup DOM mutation observer to detect removed elements
+   */
+  private setupDOMObserver(): void {
+    if (typeof MutationObserver === 'undefined') return;
+
+    this.mutationObserver = new MutationObserver((mutations) => {
+      mutations.forEach(mutation => {
+        if (mutation.type === 'childList') {
+          mutation.removedNodes.forEach(node => {
+            if (node.nodeType === Node.ELEMENT_NODE) {
+              this.handleElementRemoval(node as Element);
+            }
+          });
+        }
+      });
+    });
+
+    this.mutationObserver.observe(document.body, {
+      childList: true,
+      subtree: true
+    });
+  }
+
+  /**
+   * Handle element removal from DOM
+   */
+  private handleElementRemoval(element: Element): void {
+    // Cleanup resources for this element
+    this.cleanupElement(element);
+
+    // Also check descendants
+    const descendants = element.querySelectorAll('*');
+    descendants.forEach(descendant => {
+      this.cleanupElement(descendant);
+    });
+  }
+
+  /**
+   * Start periodic cleanup
+   */
+  private startPeriodicCleanup(): void {
+    this.cleanupInterval = window.setInterval(() => {
+      // Cleanup orphaned resources
+      let orphanedCount = 0;
+      this.elementResources.forEach((resourceIds, element) => {
+        if (!document.contains(element)) {
+          orphanedCount += this.cleanupElement(element);
+        }
+      });
+
+      // Cleanup very old resources
+      const oldCount = this.cleanupOldResources(600000); // 10 minutes
+
+      if (orphanedCount > 0 || oldCount > 0) {
+        console.log(`ProteusJS: Cleaned up ${orphanedCount} orphaned and ${oldCount} old resources`);
+      }
+    }, 60000); // Run every minute
+  }
+}

package/src/core/PerformanceMonitor.ts

@@ -0,0 +1,238 @@
+/**
+ * Performance Monitor for ProteusJS
+ * Tracks and optimizes performance metrics
+ */
+
+export interface PerformanceMetrics {
+  frameRate: number;
+  memoryUsage: number;
+  responseTime: number;
+  observerCount: number;
+  eventCount: number;
+  lastUpdate: number;
+}
+
+export class PerformanceMonitor {
+  private metrics: PerformanceMetrics;
+  private frameCount: number = 0;
+  private lastFrameTime: number = 0;
+  private frameRateHistory: number[] = [];
+  private responseTimeHistory: number[] = [];
+  private isMonitoring: boolean = false;
+  private animationFrameId: number | null = null;
+  private performanceLevel: 'low' | 'medium' | 'high';
+
+  constructor(performanceLevel: 'low' | 'medium' | 'high' = 'high') {
+    this.performanceLevel = performanceLevel;
+    this.metrics = {
+      frameRate: 0,
+      memoryUsage: 0,
+      responseTime: 0,
+      observerCount: 0,
+      eventCount: 0,
+      lastUpdate: Date.now()
+    };
+  }
+
+  /**
+   * Start performance monitoring
+   */
+  public start(): void {
+    if (this.isMonitoring) return;
+    
+    this.isMonitoring = true;
+    this.lastFrameTime = performance.now();
+    this.scheduleFrame();
+  }
+
+  /**
+   * Stop performance monitoring
+   */
+  public stop(): void {
+    if (!this.isMonitoring) return;
+    
+    this.isMonitoring = false;
+    if (this.animationFrameId) {
+      cancelAnimationFrame(this.animationFrameId);
+      this.animationFrameId = null;
+    }
+  }
+
+  /**
+   * Get current performance metrics
+   */
+  public getMetrics(): PerformanceMetrics {
+    return { ...this.metrics };
+  }
+
+  /**
+   * Record response time for an operation
+   */
+  public recordResponseTime(startTime: number): void {
+    const responseTime = performance.now() - startTime;
+    this.responseTimeHistory.push(responseTime);
+    
+    // Keep only last 100 measurements
+    if (this.responseTimeHistory.length > 100) {
+      this.responseTimeHistory.shift();
+    }
+    
+    // Calculate average response time
+    this.metrics.responseTime = this.responseTimeHistory.reduce((a, b) => a + b, 0) / this.responseTimeHistory.length;
+  }
+
+  /**
+   * Update observer count
+   */
+  public updateObserverCount(count: number): void {
+    this.metrics.observerCount = count;
+  }
+
+  /**
+   * Update event count
+   */
+  public updateEventCount(count: number): void {
+    this.metrics.eventCount = count;
+  }
+
+  /**
+   * Check if performance is within acceptable limits
+   */
+  public isPerformanceGood(): boolean {
+    const targetFrameRate = this.getTargetFrameRate();
+    const targetResponseTime = this.getTargetResponseTime();
+    
+    return this.metrics.frameRate >= targetFrameRate && 
+           this.metrics.responseTime <= targetResponseTime;
+  }
+
+  /**
+   * Get performance recommendations
+   */
+  public getRecommendations(): string[] {
+    const recommendations: string[] = [];
+    
+    if (this.metrics.frameRate < this.getTargetFrameRate()) {
+      recommendations.push('Frame rate is below target. Consider reducing animation complexity.');
+    }
+    
+    if (this.metrics.responseTime > this.getTargetResponseTime()) {
+      recommendations.push('Response time is too high. Consider optimizing calculations.');
+    }
+    
+    if (this.metrics.observerCount > this.getMaxObservers()) {
+      recommendations.push('Too many observers active. Consider lazy evaluation.');
+    }
+    
+    if (this.metrics.memoryUsage > this.getMaxMemoryUsage()) {
+      recommendations.push('Memory usage is high. Check for memory leaks.');
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Get performance score (0-100)
+   */
+  public getPerformanceScore(): number {
+    const frameRateScore = Math.min(this.metrics.frameRate / this.getTargetFrameRate(), 1) * 30;
+    const responseTimeScore = Math.max(1 - (this.metrics.responseTime / this.getTargetResponseTime()), 0) * 30;
+    const memoryScore = Math.max(1 - (this.metrics.memoryUsage / this.getMaxMemoryUsage()), 0) * 20;
+    const observerScore = Math.max(1 - (this.metrics.observerCount / this.getMaxObservers()), 0) * 20;
+    
+    return Math.round(frameRateScore + responseTimeScore + memoryScore + observerScore);
+  }
+
+  /**
+   * Schedule next frame for monitoring
+   */
+  private scheduleFrame(): void {
+    if (!this.isMonitoring) return;
+    
+    this.animationFrameId = requestAnimationFrame((currentTime) => {
+      this.updateFrameRate(currentTime);
+      this.updateMemoryUsage();
+      this.metrics.lastUpdate = Date.now();
+      this.scheduleFrame();
+    });
+  }
+
+  /**
+   * Update frame rate calculation
+   */
+  private updateFrameRate(currentTime: number): void {
+    const deltaTime = currentTime - this.lastFrameTime;
+    this.lastFrameTime = currentTime;
+    
+    if (deltaTime > 0) {
+      const currentFrameRate = 1000 / deltaTime;
+      this.frameRateHistory.push(currentFrameRate);
+      
+      // Keep only last 60 measurements (1 second at 60fps)
+      if (this.frameRateHistory.length > 60) {
+        this.frameRateHistory.shift();
+      }
+      
+      // Calculate average frame rate
+      this.metrics.frameRate = this.frameRateHistory.reduce((a, b) => a + b, 0) / this.frameRateHistory.length;
+    }
+  }
+
+  /**
+   * Update memory usage
+   */
+  private updateMemoryUsage(): void {
+    if ('memory' in performance) {
+      const memory = (performance as any).memory;
+      this.metrics.memoryUsage = memory.usedJSHeapSize / 1024 / 1024; // MB
+    }
+  }
+
+  /**
+   * Get target frame rate based on performance level
+   */
+  private getTargetFrameRate(): number {
+    switch (this.performanceLevel) {
+      case 'low': return 30;
+      case 'medium': return 45;
+      case 'high': return 60;
+      default: return 60;
+    }
+  }
+
+  /**
+   * Get target response time based on performance level
+   */
+  private getTargetResponseTime(): number {
+    switch (this.performanceLevel) {
+      case 'low': return 100; // 100ms
+      case 'medium': return 80;  // 80ms
+      case 'high': return 60;   // 60ms
+      default: return 60;
+    }
+  }
+
+  /**
+   * Get maximum allowed observers
+   */
+  private getMaxObservers(): number {
+    switch (this.performanceLevel) {
+      case 'low': return 50;
+      case 'medium': return 100;
+      case 'high': return 200;
+      default: return 200;
+    }
+  }
+
+  /**
+   * Get maximum allowed memory usage (MB)
+   */
+  private getMaxMemoryUsage(): number {
+    switch (this.performanceLevel) {
+      case 'low': return 50;
+      case 'medium': return 100;
+      case 'high': return 200;
+      default: return 200;
+    }
+  }
+}