@rakeyshgidwani/roger-ui-bank-theme-stan-design 0.2.6 → 0.2.8

package/dist/hooks/use-memory-usage.js

@@ -0,0 +1,268 @@
+import { useState, useEffect, useCallback, useRef, useMemo } from 'react'
+
+export interface MemoryMetrics {
+  usedJSHeapSize}
+
+export interface MemoryThresholds {
+  warning}
+
+export interface MemoryCallbacks {
+  onMemoryWarning?) => void
+  onMemoryCritical?) => void
+  onMemoryLeakDetected?]) => void
+  onPerformanceScoreChange?]) => void
+}
+
+export interface MemoryOptions {
+  updateInterval?}
+
+const DEFAULT_THRESHOLDS= {
+  warning,
+  critical,
+  excellent}
+
+const DEFAULT_SAMPLE_SIZE = 10
+const MEMORY_LEAK_THRESHOLD = 0.1 // 10% increase over time
+
+export const useMemoryUsage = (options= {}) => {
+  const {
+    updateInterval = 2000,
+    sampleSize = DEFAULT_SAMPLE_SIZE,
+    thresholds = {},
+    callbacks = {}
+  } = options
+
+  const [metrics, setMetrics] = useState<MemoryMetrics>({
+    usedJSHeapSize,
+    totalJSHeapSize,
+    jsHeapSizeLimit,
+    memoryUsage,
+    memoryPercentage,
+    memoryTrend,
+    memoryLeakDetected,
+    performanceScore})
+
+  const [isMonitoring, setIsMonitoring] = useState(false)
+  const intervalIdRef = useRef<NodeJS.Timeout>()
+  const memoryHistoryRef = useRef<number[]>([])
+  const lastMemoryRef = useRef<number>(0)
+
+  // Merge default thresholds with custom ones
+  const finalThresholds = useMemo(() => ({
+    ...DEFAULT_THRESHOLDS,
+    ...thresholds
+  }), [thresholds])
+
+  // Calculate performance score based on memory usage
+  const calculatePerformanceScore = useCallback((usage)] => {
+    if (usage <= finalThresholds.excellent) return 'excellent'
+    if (usage <= finalThresholds.warning) return 'good'
+    if (usage <= finalThresholds.critical) return 'fair'
+    return 'poor'
+  }, [finalThresholds])
+
+  // Detect memory trend
+  const detectMemoryTrend = useCallback((currentUsage, previousUsage)] => {
+    const difference = currentUsage - previousUsage
+    const percentageChange = Math.abs(difference) / previousUsage
+
+    if (percentageChange < 0.02) return 'stable'
+    if (difference > 0) return 'increasing'
+    return 'decreasing'
+  }, [])
+
+  // Detect potential memory leaks
+  const detectMemoryLeak = useCallback((_usage, history])=> {
+    if (history.length < 5) return false
+
+    // Check if memory usage is consistently increasing
+    const recentHistory = history.slice(-5)
+    const isConsistentlyIncreasing = recentHistory.every((value, index) => {
+      if (index === 0) return true
+      return value >= recentHistory[index - 1]
+    })
+
+    if (!isConsistentlyIncreasing) return false
+
+    // Check if the increase is significant
+    const firstValue = recentHistory[0]
+    const lastValue = recentHistory[recentHistory.length - 1]
+    const increase = (lastValue - firstValue) / firstValue
+
+    return increase > MEMORY_LEAK_THRESHOLD
+  }, [])
+
+  // Update memory information
+  const updateMemoryInfo = useCallback(() => {
+    if ('memory' in performance) {
+      const memory = (performance as any).memory
+      const usedJSHeapSize = memory.usedJSHeapSize
+      const totalJSHeapSize = memory.totalJSHeapSize
+      const jsHeapSizeLimit = memory.jsHeapSizeLimit
+      
+      const memoryUsage = usedJSHeapSize / jsHeapSizeLimit
+      const memoryPercentage = memoryUsage * 100
+
+      // Update memory history
+      memoryHistoryRef.current.push(memoryUsage)
+      if (memoryHistoryRef.current.length > sampleSize) {
+        memoryHistoryRef.current.shift()
+      }
+
+      // Detect memory trend
+      const memoryTrend = detectMemoryTrend(memoryUsage, lastMemoryRef.current)
+      
+      // Detect memory leaks
+      const memoryLeakDetected = detectMemoryLeak(memoryUsage, memoryHistoryRef.current)
+      
+      // Calculate performance score
+      const performanceScore = calculatePerformanceScore(memoryUsage)
+
+      const newMetrics= {
+        usedJSHeapSize,
+        totalJSHeapSize,
+        jsHeapSizeLimit,
+        memoryUsage,
+        memoryPercentage,
+        memoryTrend,
+        memoryLeakDetected,
+        performanceScore
+      }
+
+      setMetrics(newMetrics)
+
+      // Check thresholds and call callbacks
+      if (memoryUsage >= finalThresholds.critical && callbacks.onMemoryCritical) {
+        callbacks.onMemoryCritical(memoryUsage)
+      } else if (memoryUsage >= finalThresholds.warning && callbacks.onMemoryWarning) {
+        callbacks.onMemoryWarning(memoryUsage)
+      }
+
+      if (memoryLeakDetected && callbacks.onMemoryLeakDetected) {
+        callbacks.onMemoryLeakDetected(memoryTrend)
+      }
+
+      // Check if performance score changed
+      if (performanceScore !== metrics.performanceScore && callbacks.onPerformanceScoreChange) {
+        callbacks.onPerformanceScoreChange(performanceScore)
+      }
+
+      lastMemoryRef.current = memoryUsage
+    }
+  }, [finalThresholds, callbacks, metrics.performanceScore, detectMemoryTrend, detectMemoryLeak, calculatePerformanceScore, sampleSize])
+
+  // Start monitoring
+  const startMonitoring = useCallback(() => {
+    if (isMonitoring) return
+
+    setIsMonitoring(true)
+    
+    // Initial memory check
+    updateMemoryInfo()
+    
+    // Set up interval for memory updates
+    intervalIdRef.current = setInterval(updateMemoryInfo, updateInterval)
+  }, [isMonitoring, updateMemoryInfo, updateInterval])
+
+  // Stop monitoring
+  const stopMonitoring = useCallback(() => {
+    setIsMonitoring(false)
+    
+    if (intervalIdRef.current) {
+      clearInterval(intervalIdRef.current)
+    }
+  }, [])
+
+  // Reset statistics
+  const resetStats = useCallback(() => {
+    memoryHistoryRef.current = []
+    lastMemoryRef.current = 0
+    setMetrics(prev => ({
+      ...prev,
+      memoryTrend,
+      memoryLeakDetected}))
+  }, [])
+
+  // Auto-start monitoring on mount
+  useEffect(() => {
+    startMonitoring()
+    return () => stopMonitoring()
+  }, [startMonitoring, stopMonitoring])
+
+  // Memory optimization recommendations
+  const getOptimizationRecommendations = useCallback(() => {
+    const recommendations] = []
+    
+    if (metrics.memoryUsage >= finalThresholds.critical) {
+      recommendations.push('Critical memory usage - consider implementing memory cleanup and lazy loading')
+    } else if (metrics.memoryUsage >= finalThresholds.warning) {
+      recommendations.push('High memory usage - monitor for memory leaks and optimize resource usage')
+    }
+    
+    if (metrics.memoryLeakDetected) {
+      recommendations.push('Potential memory leak detected - investigate resource cleanup and event listeners')
+    }
+    
+    if (metrics.memoryTrend === 'increasing') {
+      recommendations.push('Memory usage is increasing - check for proper cleanup in useEffect and event handlers')
+    }
+    
+    if (metrics.memoryPercentage > 80) {
+      recommendations.push('Memory usage above 80% - consider implementing virtual scrolling or pagination')
+    }
+    
+    return recommendations
+  }, [metrics, finalThresholds])
+
+  // Memory cleanup suggestions
+  const getCleanupSuggestions = useCallback(() => {
+    const suggestions] = []
+    
+    if (metrics.memoryLeakDetected) {
+      suggestions.push('Review useEffect cleanup functions')
+      suggestions.push('Check for unremoved event listeners')
+      suggestions.push('Verify proper cleanup in component unmount')
+      suggestions.push('Consider using AbortController for fetch requests')
+    }
+    
+    if (metrics.memoryTrend === 'increasing') {
+      suggestions.push('Implement proper cleanup in useEffect return functions')
+      suggestions.push('Review component lifecycle management')
+      suggestions.push('Check for circular references')
+    }
+    
+    return suggestions
+  }, [metrics])
+
+  return {
+    // Metrics
+    metrics,
+    
+    // Controls
+    startMonitoring,
+    stopMonitoring,
+    isMonitoring,
+    resetStats,
+    
+    // Performance analysis
+    performanceScore,
+    memoryTrend,
+    memoryLeakDetected,
+    
+    // Optimization
+    getOptimizationRecommendations,
+    getCleanupSuggestions,
+    
+    // Raw values
+    usedJSHeapSize,
+    totalJSHeapSize,
+    jsHeapSizeLimit,
+    memoryUsage,
+    memoryPercentage,
+    
+    // Thresholds
+    thresholds,
+    
+    // History
+    memoryHistory}
+}