@rakeyshgidwani/roger-ui-bank-theme-stan-design 0.2.11 → 0.2.17

package/dist/hooks/use-memory-usage.d.ts

@@ -1,285 +1,51 @@
 export interface MemoryMetrics {
-  usedJSHeapSize: number
-  totalJSHeapSize: number
-  jsHeapSizeLimit: number
-  memoryUsage: number
-  memoryPercentage: number
-  memoryTrend: 'increasing' | 'decreasing' | 'stable'
-  memoryLeakDetected: boolean
-  performanceScore: 'excellent' | 'good' | 'fair' | 'poor'
+    usedJSHeapSize: number;
+    totalJSHeapSize: number;
+    jsHeapSizeLimit: number;
+    memoryUsage: number;
+    memoryPercentage: number;
+    memoryTrend: 'increasing' | 'decreasing' | 'stable';
+    memoryLeakDetected: boolean;
+    performanceScore: 'excellent' | 'good' | 'fair' | 'poor';
 }
-
 export interface MemoryThresholds {
-  warning: number
-  critical: number
-  excellent: number
+    warning: number;
+    critical: number;
+    excellent: number;
 }
-
 export interface MemoryCallbacks {
-  onMemoryWarning?: (usage: number) => void
-  onMemoryCritical?: (usage: number) => void
-  onMemoryLeakDetected?: (trend: MemoryMetrics['memoryTrend']) => void
-  onPerformanceScoreChange?: (score: MemoryMetrics['performanceScore']) => void
+    onMemoryWarning?: (usage: number) => void;
+    onMemoryCritical?: (usage: number) => void;
+    onMemoryLeakDetected?: (trend: MemoryMetrics['memoryTrend']) => void;
+    onPerformanceScoreChange?: (score: MemoryMetrics['performanceScore']) => void;
 }
-
 export interface MemoryOptions {
-  updateInterval?: number
-  sampleSize?: number
-  thresholds?: Partial<MemoryThresholds>
-  callbacks?: MemoryCallbacks
-}
-
-const DEFAULT_THRESHOLDS: MemoryThresholds = {
-  warning: 0.7,
-  critical: 0.85,
-  excellent: 0.5
-}
-
-const DEFAULT_SAMPLE_SIZE = 10
-const MEMORY_LEAK_THRESHOLD = 0.1 // 10% increase over time
-
-export declare const useMemoryUsage: (options: MemoryOptions = {}) => {
-  const {
-    updateInterval = 2000,
-    sampleSize = DEFAULT_SAMPLE_SIZE,
-    thresholds = {},
-    callbacks = {}
-  } = options
-
-  const [metrics, setMetrics] = useState<MemoryMetrics>({
-    usedJSHeapSize: 0,
-    totalJSHeapSize: 0,
-    jsHeapSizeLimit: 0,
-    memoryUsage: 0,
-    memoryPercentage: 0,
-    memoryTrend: 'stable',
-    memoryLeakDetected: false,
-    performanceScore: 'excellent'
-  })
-
-  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: number): MemoryMetrics['performanceScore'] => {
-    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: number, previousUsage: number): MemoryMetrics['memoryTrend'] => {
-    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: number, history: number[]): boolean => {
-    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: MemoryMetrics = {
-        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: 'stable',
-      memoryLeakDetected: false
-    }))
-  }, [])
-
-  // Auto-start monitoring on mount
-  useEffect(() => {
-    startMonitoring()
-    return () => stopMonitoring()
-  }, [startMonitoring, stopMonitoring])
-
-  // Memory optimization recommendations
-  const getOptimizationRecommendations = useCallback(() => {
-    const recommendations: string[] = []
-
-    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: string[] = []
-
-    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: metrics.performanceScore,
-    memoryTrend: metrics.memoryTrend,
-    memoryLeakDetected: metrics.memoryLeakDetected,
-
-    // Optimization
-    getOptimizationRecommendations,
-    getCleanupSuggestions,
-
-    // Raw values
-    usedJSHeapSize: metrics.usedJSHeapSize,
-    totalJSHeapSize: metrics.totalJSHeapSize,
-    jsHeapSizeLimit: metrics.jsHeapSizeLimit,
-    memoryUsage: metrics.memoryUsage,
-    memoryPercentage: metrics.memoryPercentage,
-
-    // Thresholds
-    thresholds: finalThresholds,
-
-    // History
-    memoryHistory: memoryHistoryRef.current
-  }
+    updateInterval?: number;
+    sampleSize?: number;
+    thresholds?: Partial<MemoryThresholds>;
+    callbacks?: MemoryCallbacks;
 }
+export declare const useMemoryUsage: (options?: MemoryOptions) => {
+    metrics: MemoryMetrics;
+    startMonitoring: () => void;
+    stopMonitoring: () => void;
+    isMonitoring: boolean;
+    resetStats: () => void;
+    performanceScore: "excellent" | "good" | "fair" | "poor";
+    memoryTrend: "stable" | "increasing" | "decreasing";
+    memoryLeakDetected: boolean;
+    getOptimizationRecommendations: () => string[];
+    getCleanupSuggestions: () => string[];
+    usedJSHeapSize: number;
+    totalJSHeapSize: number;
+    jsHeapSizeLimit: number;
+    memoryUsage: number;
+    memoryPercentage: number;
+    thresholds: {
+        warning: number;
+        critical: number;
+        excellent: number;
+    };
+    memoryHistory: number[];
+};
+//# sourceMappingURL=use-memory-usage.d.ts.map

package/dist/hooks/use-memory-usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-memory-usage.d.ts","sourceRoot":"","sources":["../../src/hooks/use-memory-usage.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,aAAa;IAC5B,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,MAAM,CAAA;IACvB,eAAe,EAAE,MAAM,CAAA;IACvB,WAAW,EAAE,MAAM,CAAA;IACnB,gBAAgB,EAAE,MAAM,CAAA;IACxB,WAAW,EAAE,YAAY,GAAG,YAAY,GAAG,QAAQ,CAAA;IACnD,kBAAkB,EAAE,OAAO,CAAA;IAC3B,gBAAgB,EAAE,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAA;CACzD;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACzC,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1C,oBAAoB,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,aAAa,CAAC,KAAK,IAAI,CAAA;IACpE,wBAAwB,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,kBAAkB,CAAC,KAAK,IAAI,CAAA;CAC9E;AAED,MAAM,WAAW,aAAa;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAA;IACtC,SAAS,CAAC,EAAE,eAAe,CAAA;CAC5B;AAWD,eAAO,MAAM,cAAc,GAAI,UAAS,aAAkB;;;;;;;;;;;;;;;;;iBA5B/C,MAAM;kBACL,MAAM;mBACL,MAAM;;;CA8QlB,CAAA"}