{"version":3,"file":"memory-optimizer.mjs","sources":["../../../../src/lib/performance/advanced/memory-optimizer.ts"],"sourcesContent":["/**\n * @file Memory Optimization Utilities\n * @description Memory leak prevention, garbage collection optimization,\n * and memory pressure handling for React applications.\n *\n * Features:\n * - Memory leak detection\n * - Weak reference management\n * - Object pool management\n * - Cache eviction strategies\n * - Memory pressure monitoring\n * - Cleanup orchestration\n */\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/**\n * Memory pressure level\n */\nexport type MemoryPressureLevel = 'none' | 'moderate' | 'critical';\n\n/**\n * Memory statistics\n */\nexport interface MemoryStats {\n usedJSHeapSize: number;\n totalJSHeapSize: number;\n jsHeapSizeLimit: number;\n usagePercent: number;\n pressureLevel: MemoryPressureLevel;\n timestamp: number;\n}\n\n/**\n * Memory leak suspect\n */\nexport interface MemoryLeakSuspect {\n type: string;\n count: number;\n estimatedSize: number;\n growthRate: number;\n firstSeen: number;\n lastSeen: number;\n stackTrace?: string;\n}\n\n/**\n * Object pool configuration\n */\nexport interface ObjectPoolConfig {\n /** Factory function to create new objects */\n create: () => T;\n /** Reset function to clear object state */\n reset: (obj: T) => void;\n /** Maximum pool size */\n maxSize: number;\n /** Minimum objects to keep in pool */\n minSize: number;\n /** Auto-shrink pool when idle */\n autoShrink: boolean;\n /** Shrink interval in ms */\n shrinkInterval: number;\n}\n\n/**\n * Cache configuration\n */\nexport interface CacheConfig {\n /** Maximum number of entries */\n maxEntries: number;\n /** Maximum memory size in bytes */\n maxMemorySize: number;\n /** Time-to-live in ms */\n ttl: number;\n /** Eviction policy */\n evictionPolicy: 'lru' | 'lfu' | 'fifo';\n /** Enable memory pressure response */\n memoryPressureAware: boolean;\n}\n\n/**\n * Cache entry\n */\ninterface CacheEntry {\n value: T;\n size: number;\n accessCount: number;\n lastAccess: number;\n createdAt: number;\n expiresAt: number;\n}\n\n/**\n * Cleanup callback\n */\nexport type CleanupCallback = () => void | Promise;\n\n/**\n * Memory pressure callback\n */\nexport type MemoryPressureCallback = (level: MemoryPressureLevel) => void;\n\n// ============================================================================\n// Constants\n// ============================================================================\n\nconst MEMORY_PRESSURE_THRESHOLDS = {\n moderate: 70, // 70% of heap limit\n critical: 90, // 90% of heap limit\n};\n\n// ============================================================================\n// Memory Monitor\n// ============================================================================\n\n/**\n * Memory monitoring and pressure detection\n */\nexport class MemoryMonitor {\n private pressureCallbacks: Set = new Set();\n private lastPressureLevel: MemoryPressureLevel = 'none';\n private monitorInterval: ReturnType | null = null;\n private history: MemoryStats[] = [];\n private maxHistorySize = 100;\n\n /**\n * Start monitoring memory\n */\n start(intervalMs: number = 5000): void {\n if (this.monitorInterval !== null) {\n return;\n }\n\n this.monitorInterval = setInterval(() => {\n this.checkMemory();\n }, intervalMs);\n\n // Initial check\n this.checkMemory();\n }\n\n /**\n * Stop monitoring\n */\n stop(): void {\n if (this.monitorInterval) {\n clearInterval(this.monitorInterval);\n this.monitorInterval = null;\n }\n }\n\n /**\n * Get current memory stats\n */\n getStats(): MemoryStats | null {\n const memory = this.getMemoryInfo();\n if (memory === null) {\n return null;\n }\n\n const usagePercent = (memory.usedJSHeapSize / memory.jsHeapSizeLimit) * 100;\n\n return {\n usedJSHeapSize: memory.usedJSHeapSize,\n totalJSHeapSize: memory.totalJSHeapSize,\n jsHeapSizeLimit: memory.jsHeapSizeLimit,\n usagePercent,\n pressureLevel: this.calculatePressureLevel(usagePercent),\n timestamp: Date.now(),\n };\n }\n\n /**\n * Get memory history\n */\n getHistory(): MemoryStats[] {\n return [...this.history];\n }\n\n /**\n * Subscribe to memory pressure changes\n */\n onPressureChange(callback: MemoryPressureCallback): () => void {\n this.pressureCallbacks.add(callback);\n return () => this.pressureCallbacks.delete(callback);\n }\n\n /**\n * Force garbage collection (if available)\n */\n forceGC(): boolean {\n const globalWithGC = globalThis as typeof globalThis & { gc?: () => void };\n if (typeof globalWithGC.gc === 'function') {\n globalWithGC.gc();\n return true;\n }\n return false;\n }\n\n // ============================================================================\n // Private Methods\n // ============================================================================\n\n private getMemoryInfo(): {\n usedJSHeapSize: number;\n totalJSHeapSize: number;\n jsHeapSizeLimit: number;\n } | null {\n const perf = performance as Performance & {\n memory?: {\n usedJSHeapSize: number;\n totalJSHeapSize: number;\n jsHeapSizeLimit: number;\n };\n };\n\n return perf.memory ?? null;\n }\n\n private checkMemory(): void {\n const stats = this.getStats();\n if (stats === null) {\n return;\n }\n\n // Add to history\n this.history.push(stats);\n if (this.history.length > this.maxHistorySize) {\n this.history.shift();\n }\n\n // Check for pressure level change\n if (stats.pressureLevel !== this.lastPressureLevel) {\n this.lastPressureLevel = stats.pressureLevel;\n this.notifyPressureChange(stats.pressureLevel);\n }\n }\n\n private calculatePressureLevel(usagePercent: number): MemoryPressureLevel {\n if (usagePercent >= MEMORY_PRESSURE_THRESHOLDS.critical) {\n return 'critical';\n }\n if (usagePercent >= MEMORY_PRESSURE_THRESHOLDS.moderate) {\n return 'moderate';\n }\n return 'none';\n }\n\n private notifyPressureChange(level: MemoryPressureLevel): void {\n this.pressureCallbacks.forEach((callback) => callback(level));\n }\n}\n\n// ============================================================================\n// Object Pool\n// ============================================================================\n\n/**\n * Generic object pool for reducing GC pressure\n */\nexport class ObjectPool {\n private config: ObjectPoolConfig;\n private pool: T[] = [];\n private activeCount = 0;\n private shrinkTimer: ReturnType | null = null;\n\n constructor(config: ObjectPoolConfig) {\n this.config = config;\n\n // Pre-populate pool\n for (let i = 0; i < config.minSize; i++) {\n this.pool.push(config.create());\n }\n\n if (config.autoShrink) {\n this.startAutoShrink();\n }\n }\n\n /**\n * Acquire an object from the pool\n */\n acquire(): T {\n this.activeCount++;\n\n if (this.pool.length > 0) {\n const obj = this.pool.pop();\n if (obj !== undefined) {\n return obj;\n }\n }\n\n return this.config.create();\n }\n\n /**\n * Release an object back to the pool\n */\n release(obj: T): void {\n this.activeCount = Math.max(0, this.activeCount - 1);\n\n if (this.pool.length < this.config.maxSize) {\n this.config.reset(obj);\n this.pool.push(obj);\n }\n }\n\n /**\n * Get pool statistics\n */\n getStats(): { poolSize: number; activeCount: number; maxSize: number } {\n return {\n poolSize: this.pool.length,\n activeCount: this.activeCount,\n maxSize: this.config.maxSize,\n };\n }\n\n /**\n * Clear the pool\n */\n clear(): void {\n this.pool = [];\n }\n\n /**\n * Destroy the pool\n */\n destroy(): void {\n this.clear();\n if (this.shrinkTimer) {\n clearInterval(this.shrinkTimer);\n this.shrinkTimer = null;\n }\n }\n\n // ============================================================================\n // Private Methods\n // ============================================================================\n\n private startAutoShrink(): void {\n this.shrinkTimer = setInterval(() => {\n this.shrink();\n }, this.config.shrinkInterval);\n }\n\n private shrink(): void {\n const targetSize = Math.max(this.config.minSize, Math.ceil(this.activeCount * 1.5));\n\n while (this.pool.length > targetSize) {\n this.pool.pop();\n }\n }\n}\n\n// ============================================================================\n// Memory-Aware Cache\n// ============================================================================\n\n/**\n * Cache with memory pressure awareness and multiple eviction strategies\n */\nexport class MemoryAwareCache {\n private config: CacheConfig;\n private cache: Map> = new Map();\n private currentMemorySize = 0;\n private memoryMonitor: MemoryMonitor | null = null;\n\n constructor(config: Partial = {}) {\n this.config = {\n maxEntries: config.maxEntries ?? 1000,\n maxMemorySize: config.maxMemorySize ?? 50 * 1024 * 1024, // 50MB\n ttl: config.ttl ?? 5 * 60 * 1000, // 5 minutes\n evictionPolicy: config.evictionPolicy ?? 'lru',\n memoryPressureAware: config.memoryPressureAware ?? true,\n };\n\n if (this.config.memoryPressureAware) {\n this.setupMemoryPressureResponse();\n }\n }\n\n /**\n * Get a value from cache\n */\n get(key: K): V | undefined {\n const entry = this.cache.get(key);\n\n if (entry === undefined) {\n return undefined;\n }\n\n // Check expiration\n if (Date.now() > entry.expiresAt) {\n this.delete(key);\n return undefined;\n }\n\n // Update access info\n entry.accessCount++;\n entry.lastAccess = Date.now();\n\n return entry.value;\n }\n\n /**\n * Set a value in cache\n */\n set(key: K, value: V, sizeEstimate?: number): void {\n const size = sizeEstimate ?? this.estimateSize(value);\n const now = Date.now();\n\n // Evict if necessary\n while (\n (this.cache.size >= this.config.maxEntries ||\n this.currentMemorySize + size > this.config.maxMemorySize) &&\n this.cache.size > 0\n ) {\n this.evictOne();\n }\n\n // Remove existing entry if present\n if (this.cache.has(key)) {\n this.delete(key);\n }\n\n const entry: CacheEntry = {\n value,\n size,\n accessCount: 1,\n lastAccess: now,\n createdAt: now,\n expiresAt: now + this.config.ttl,\n };\n\n this.cache.set(key, entry);\n this.currentMemorySize += size;\n }\n\n /**\n * Delete a value from cache\n */\n delete(key: K): boolean {\n const entry = this.cache.get(key);\n if (entry) {\n this.currentMemorySize -= entry.size;\n return this.cache.delete(key);\n }\n return false;\n }\n\n /**\n * Check if key exists\n */\n has(key: K): boolean {\n const entry = this.cache.get(key);\n if (entry === undefined) {\n return false;\n }\n if (Date.now() > entry.expiresAt) {\n this.delete(key);\n return false;\n }\n return true;\n }\n\n /**\n * Clear the cache\n */\n clear(): void {\n this.cache.clear();\n this.currentMemorySize = 0;\n }\n\n /**\n * Get cache statistics\n */\n getStats(): {\n size: number;\n memorySize: number;\n maxEntries: number;\n maxMemorySize: number;\n } {\n return {\n size: this.cache.size,\n memorySize: this.currentMemorySize,\n maxEntries: this.config.maxEntries,\n maxMemorySize: this.config.maxMemorySize,\n };\n }\n\n /**\n * Cleanup expired entries\n */\n cleanup(): number {\n const now = Date.now();\n let cleaned = 0;\n\n for (const [key, entry] of this.cache.entries()) {\n if (now > entry.expiresAt) {\n this.delete(key);\n cleaned++;\n }\n }\n\n return cleaned;\n }\n\n /**\n * Destroy the cache and cleanup resources\n */\n destroy(): void {\n this.clear();\n if (this.memoryMonitor) {\n this.memoryMonitor.stop();\n this.memoryMonitor = null;\n }\n }\n\n // ============================================================================\n // Private Methods\n // ============================================================================\n\n private setupMemoryPressureResponse(): void {\n this.memoryMonitor = new MemoryMonitor();\n this.memoryMonitor.onPressureChange((level) => {\n if (level === 'critical') {\n // Evict 50% of cache\n const targetSize = Math.floor(this.cache.size / 2);\n while (this.cache.size > targetSize) {\n this.evictOne();\n }\n } else if (level === 'moderate') {\n // Evict 25% of cache\n const targetSize = Math.floor(this.cache.size * 0.75);\n while (this.cache.size > targetSize) {\n this.evictOne();\n }\n }\n });\n this.memoryMonitor.start();\n }\n\n private evictOne(): void {\n const keyToEvict = this.selectEvictionCandidate();\n if (keyToEvict !== undefined) {\n this.delete(keyToEvict);\n }\n }\n\n private selectEvictionCandidate(): K | undefined {\n if (this.cache.size === 0) {\n return undefined;\n }\n\n switch (this.config.evictionPolicy) {\n case 'lru':\n return this.selectLRUCandidate();\n case 'lfu':\n return this.selectLFUCandidate();\n case 'fifo':\n return this.selectFIFOCandidate();\n default:\n return this.cache.keys().next().value;\n }\n }\n\n private selectLRUCandidate(): K | undefined {\n let oldestKey: K | undefined;\n let oldestAccess = Infinity;\n\n for (const [key, entry] of this.cache.entries()) {\n if (entry.lastAccess < oldestAccess) {\n oldestAccess = entry.lastAccess;\n oldestKey = key;\n }\n }\n\n return oldestKey;\n }\n\n private selectLFUCandidate(): K | undefined {\n let leastKey: K | undefined;\n let leastCount = Infinity;\n\n for (const [key, entry] of this.cache.entries()) {\n if (entry.accessCount < leastCount) {\n leastCount = entry.accessCount;\n leastKey = key;\n }\n }\n\n return leastKey;\n }\n\n private selectFIFOCandidate(): K | undefined {\n let oldestKey: K | undefined;\n let oldestCreated = Infinity;\n\n for (const [key, entry] of this.cache.entries()) {\n if (entry.createdAt < oldestCreated) {\n oldestCreated = entry.createdAt;\n oldestKey = key;\n }\n }\n\n return oldestKey;\n }\n\n private estimateSize(value: V): number {\n // Rough estimation based on JSON serialization\n try {\n return new Blob([JSON.stringify(value)]).size;\n } catch {\n return 1024; // Default estimate for non-serializable objects\n }\n }\n}\n\n// ============================================================================\n// Cleanup Orchestrator\n// ============================================================================\n\n/**\n * Orchestrates cleanup across multiple resources\n */\nexport class CleanupOrchestrator {\n private cleanupCallbacks: Map = new Map();\n private isDestroyed = false;\n\n /**\n * Register a cleanup callback\n */\n register(id: string, callback: CleanupCallback): () => void {\n if (this.isDestroyed) {\n console.warn('[CleanupOrchestrator] Cannot register after destruction');\n return () => {};\n }\n\n this.cleanupCallbacks.set(id, callback);\n return () => this.unregister(id);\n }\n\n /**\n * Unregister a cleanup callback\n */\n unregister(id: string): void {\n this.cleanupCallbacks.delete(id);\n }\n\n /**\n * Run a specific cleanup\n */\n async cleanup(id: string): Promise {\n const callback = this.cleanupCallbacks.get(id);\n if (callback !== undefined) {\n await callback();\n }\n }\n\n /**\n * Run all cleanups\n */\n async cleanupAll(): Promise {\n const promises: Promise[] = [];\n\n for (const callback of this.cleanupCallbacks.values()) {\n promises.push(Promise.resolve(callback()));\n }\n\n await Promise.all(promises);\n }\n\n /**\n * Destroy the orchestrator and run all cleanups\n */\n async destroy(): Promise {\n if (this.isDestroyed) {\n return;\n }\n\n this.isDestroyed = true;\n await this.cleanupAll();\n this.cleanupCallbacks.clear();\n }\n}\n\n// ============================================================================\n// WeakRef Manager\n// ============================================================================\n\n/**\n * Manages weak references with automatic cleanup\n */\nexport class WeakRefManager {\n private refs: Map> = new Map();\n private finalizationRegistry: FinalizationRegistry;\n private cleanupCallbacks: Map void> = new Map();\n\n constructor() {\n this.finalizationRegistry = new FinalizationRegistry((key: string) => {\n this.refs.delete(key);\n const callback = this.cleanupCallbacks.get(key);\n if (callback !== undefined) {\n callback();\n this.cleanupCallbacks.delete(key);\n }\n });\n }\n\n /**\n * Add a weak reference\n */\n set(key: string, value: T, onCleanup?: () => void): void {\n const existingRef = this.refs.get(key);\n if (existingRef !== undefined) {\n // Cannot unregister from FinalizationRegistry, so we just overwrite\n }\n\n this.refs.set(key, new WeakRef(value));\n this.finalizationRegistry.register(value, key);\n\n if (onCleanup !== undefined) {\n this.cleanupCallbacks.set(key, onCleanup);\n }\n }\n\n /**\n * Get a weak reference (may return undefined if collected)\n */\n get(key: string): T | undefined {\n const ref = this.refs.get(key);\n return ref?.deref();\n }\n\n /**\n * Check if reference exists and is alive\n */\n has(key: string): boolean {\n return this.get(key) !== undefined;\n }\n\n /**\n * Delete a reference\n */\n delete(key: string): boolean {\n this.cleanupCallbacks.delete(key);\n return this.refs.delete(key);\n }\n\n /**\n * Get all live references\n */\n getLive(): Map {\n const live = new Map();\n\n for (const [key, ref] of this.refs.entries()) {\n const value = ref.deref();\n if (value !== undefined) {\n live.set(key, value);\n }\n }\n\n return live;\n }\n\n /**\n * Clean up dead references\n */\n prune(): number {\n let pruned = 0;\n\n for (const [key, ref] of this.refs.entries()) {\n if (ref.deref() === undefined) {\n this.refs.delete(key);\n this.cleanupCallbacks.delete(key);\n pruned++;\n }\n }\n\n return pruned;\n }\n}\n\n// ============================================================================\n// Memory Leak Detector\n// ============================================================================\n\n/**\n * Detects potential memory leaks by tracking object allocations\n */\nexport class MemoryLeakDetector {\n private tracking: Map<\n string,\n { count: number; firstSeen: number; lastSeen: number; samples: number[] }\n > = new Map();\n private interval: ReturnType | null = null;\n private growthThreshold = 1.5; // 50% growth indicates potential leak\n\n /**\n * Start tracking a category of objects\n */\n track(category: string, count: number): void {\n const now = Date.now();\n const existing = this.tracking.get(category);\n\n if (existing) {\n existing.count = count;\n existing.lastSeen = now;\n existing.samples.push(count);\n\n // Keep last 20 samples\n if (existing.samples.length > 20) {\n existing.samples.shift();\n }\n } else {\n this.tracking.set(category, {\n count,\n firstSeen: now,\n lastSeen: now,\n samples: [count],\n });\n }\n }\n\n /**\n * Get potential memory leak suspects\n */\n getSuspects(): MemoryLeakSuspect[] {\n const suspects: MemoryLeakSuspect[] = [];\n\n for (const [type, data] of this.tracking.entries()) {\n if (data.samples.length < 5) {\n continue;\n }\n\n const firstSamples = data.samples.slice(0, 5);\n const lastSamples = data.samples.slice(-5);\n\n const avgFirst = firstSamples.reduce((a, b) => a + b, 0) / firstSamples.length;\n const avgLast = lastSamples.reduce((a, b) => a + b, 0) / lastSamples.length;\n\n const growthRate = avgLast / avgFirst;\n\n if (growthRate >= this.growthThreshold) {\n suspects.push({\n type,\n count: data.count,\n estimatedSize: data.count * 100, // Rough estimate\n growthRate,\n firstSeen: data.firstSeen,\n lastSeen: data.lastSeen,\n });\n }\n }\n\n return suspects.sort((a, b) => b.growthRate - a.growthRate);\n }\n\n /**\n * Clear tracking data\n */\n clear(): void {\n this.tracking.clear();\n }\n\n /**\n * Start automatic detection\n */\n startAutoDetection(intervalMs: number = 10000): void {\n if (this.interval) {\n return;\n }\n\n this.interval = setInterval(() => {\n const suspects = this.getSuspects();\n if (suspects.length > 0) {\n console.warn('[MemoryLeakDetector] Potential memory leaks detected:', suspects);\n }\n }, intervalMs);\n }\n\n /**\n * Stop automatic detection\n */\n stopAutoDetection(): void {\n if (this.interval) {\n clearInterval(this.interval);\n this.interval = null;\n }\n }\n}\n\n// ============================================================================\n// Singleton Instances\n// ============================================================================\n\nlet memoryMonitorInstance: MemoryMonitor | null = null;\nlet cleanupOrchestratorInstance: CleanupOrchestrator | null = null;\n\n/**\n * Get the global memory monitor instance\n */\nexport function getMemoryMonitor(): MemoryMonitor {\n memoryMonitorInstance ??= new MemoryMonitor();\n return memoryMonitorInstance;\n}\n\n/**\n * Get the global cleanup orchestrator instance\n */\nexport function getCleanupOrchestrator(): CleanupOrchestrator {\n cleanupOrchestratorInstance ??= new CleanupOrchestrator();\n return cleanupOrchestratorInstance;\n}\n"],"names":["MEMORY_PRESSURE_THRESHOLDS","MemoryMonitor","intervalMs","memory","usagePercent","callback","globalWithGC","stats","level","ObjectPool","config","i","obj","targetSize","MemoryAwareCache","key","entry","value","sizeEstimate","size","now","cleaned","keyToEvict","oldestKey","oldestAccess","leastKey","leastCount","oldestCreated","CleanupOrchestrator","id","promises","WeakRefManager","onCleanup","live","ref","pruned","MemoryLeakDetector","category","count","existing","suspects","type","data","firstSamples","lastSamples","avgFirst","a","b","growthRate","memoryMonitorInstance","cleanupOrchestratorInstance","getMemoryMonitor","getCleanupOrchestrator"],"mappings":"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"}