@rakeyshgidwani/roger-ui-bank-theme-stan-design 0.2.10 → 0.2.16

package/dist/hooks/use-performance.js

@@ -1,316 +1,219 @@
-import { useState, useEffect, useCallback, useMemo, useRef } from 'react'
-
-export interface PerformanceMetrics {
-  fps: number
-  frameTime: number
-  memoryUsage?: number
-  memoryLimit?: number
-  memoryPercentage?: number
-  batteryLevel?: number
-  isLowPowerMode?: boolean
-  isCharging?: boolean
-  performanceMode: 'high' | 'medium' | 'low'
-  throttlingEnabled: boolean
-  throttlingReason?: string
-}
-
-export interface PerformanceThresholds {
-  fps: {
-    warning: number
-    critical: number
-  }
-  memory: {
-    warning: number
-    critical: number
-  }
-  battery: {
-    low: number
-    critical: number
-  }
-}
-
-export interface PerformanceCallbacks {
-  onFPSWarning?: (fps: number) => void
-  onMemoryWarning?: (usage: number) => void
-  onBatteryLow?: (level: number) => void
-  onPerformanceModeChange?: (mode: PerformanceMetrics['performanceMode']) => void
-  onThrottlingChange?: (enabled: boolean, reason?: string) => void
-}
-
-export interface PerformanceOptions {
-  updateInterval?: number
-  thresholds?: Partial<PerformanceThresholds>
-  enableThrottling?: boolean
-  enableBatteryOptimization?: boolean
-  callbacks?: PerformanceCallbacks
-}
-
-const DEFAULT_THRESHOLDS: PerformanceThresholds = {
-  fps: {
-    warning: 45,
-    critical: 30
-  },
-  memory: {
-    warning: 0.7,
-    critical: 0.85
-  },
-  battery: {
-    low: 0.3,
-    critical: 0.15
-  }
-}
-
-export const usePerformance = (options: PerformanceOptions = {}) => {
-  const {
-    updateInterval = 1000,
-    thresholds = {},
-    enableThrottling = true,
-    enableBatteryOptimization = true,
-    callbacks = {}
-  } = options
-
-  const [metrics, setMetrics] = useState<PerformanceMetrics>({
-    fps: 60,
-    frameTime: 16.67,
-    performanceMode: 'high',
-    throttlingEnabled: false
-  })
-
-  const [isMonitoring, setIsMonitoring] = useState(false)
-  const frameCountRef = useRef(0)
-  const lastTimeRef = useRef(performance.now())
-  const animationIdRef = useRef<number>()
-  const intervalIdRef = useRef<NodeJS.Timeout>()
-
-  // Merge default thresholds with custom ones
-  const finalThresholds = useMemo(() => ({
-    ...DEFAULT_THRESHOLDS,
-    ...thresholds
-  }), [thresholds])
-
-  // Frame rate monitoring
-  const measureFrameRate = useCallback(() => {
-    frameCountRef.current++
-    const currentTime = performance.now()
-    
-    if (currentTime - lastTimeRef.current >= updateInterval) {
-      const fps = Math.round((frameCountRef.current * 1000) / (currentTime - lastTimeRef.current))
-      const frameTime = 1000 / fps
-      
-      setMetrics(prev => ({
-        ...prev,
-        fps,
-        frameTime
-      }))
-
-      // Check FPS thresholds
-      if (fps <= finalThresholds.fps.critical && callbacks.onFPSWarning) {
-        callbacks.onFPSWarning(fps)
-      }
-
-      frameCountRef.current = 0
-      lastTimeRef.current = currentTime
+import { useState, useEffect, useCallback, useMemo, useRef } from 'react';
+const DEFAULT_THRESHOLDS = {
+    fps: {
+        warning: 45,
+        critical: 30
+    },
+    memory: {
+        warning: 0.7,
+        critical: 0.85
+    },
+    battery: {
+        low: 0.3,
+        critical: 0.15
     }
-
-    animationIdRef.current = requestAnimationFrame(measureFrameRate)
-  }, [updateInterval, finalThresholds.fps.critical, callbacks.onFPSWarning])
-
-  // Memory usage monitoring
-  const updateMemoryInfo = useCallback(() => {
-    if ('memory' in performance) {
-      const memory = (performance as any).memory
-      const memoryUsage = memory.usedJSHeapSize / memory.jsHeapSizeLimit
-      
-      setMetrics(prev => ({
-        ...prev,
-        memoryUsage,
-        memoryLimit: memory.jsHeapSizeLimit,
-        memoryPercentage: memoryUsage * 100
-      }))
-
-      // Check memory thresholds
-      if (memoryUsage >= finalThresholds.memory.critical && callbacks.onMemoryWarning) {
-        callbacks.onMemoryWarning(memoryUsage)
-      }
-    }
-  }, [finalThresholds.memory.critical, callbacks.onMemoryWarning])
-
-  // Battery status monitoring
-  const updateBatteryInfo = useCallback(async () => {
-    if ('getBattery' in navigator) {
-      try {
-        const battery = await (navigator as any).getBattery()
-        
+};
+export const usePerformance = (options = {}) => {
+    const { updateInterval = 1000, thresholds = {}, enableThrottling = true, enableBatteryOptimization = true, callbacks = {} } = options;
+    const [metrics, setMetrics] = useState({
+        fps: 60,
+        frameTime: 16.67,
+        performanceMode: 'high',
+        throttlingEnabled: false
+    });
+    const [isMonitoring, setIsMonitoring] = useState(false);
+    const frameCountRef = useRef(0);
+    const lastTimeRef = useRef(performance.now());
+    const animationIdRef = useRef();
+    const intervalIdRef = useRef();
+    // Merge default thresholds with custom ones
+    const finalThresholds = useMemo(() => ({
+        ...DEFAULT_THRESHOLDS,
+        ...thresholds
+    }), [thresholds]);
+    // Frame rate monitoring
+    const measureFrameRate = useCallback(() => {
+        frameCountRef.current++;
+        const currentTime = performance.now();
+        if (currentTime - lastTimeRef.current >= updateInterval) {
+            const fps = Math.round((frameCountRef.current * 1000) / (currentTime - lastTimeRef.current));
+            const frameTime = 1000 / fps;
+            setMetrics(prev => ({
+                ...prev,
+                fps,
+                frameTime
+            }));
+            // Check FPS thresholds
+            if (fps <= finalThresholds.fps.critical && callbacks.onFPSWarning) {
+                callbacks.onFPSWarning(fps);
+            }
+            frameCountRef.current = 0;
+            lastTimeRef.current = currentTime;
+        }
+        animationIdRef.current = requestAnimationFrame(measureFrameRate);
+    }, [updateInterval, finalThresholds.fps.critical, callbacks.onFPSWarning]);
+    // Memory usage monitoring
+    const updateMemoryInfo = useCallback(() => {
+        if ('memory' in performance) {
+            const memory = performance.memory;
+            const memoryUsage = memory.usedJSHeapSize / memory.jsHeapSizeLimit;
+            setMetrics(prev => ({
+                ...prev,
+                memoryUsage,
+                memoryLimit: memory.jsHeapSizeLimit,
+                memoryPercentage: memoryUsage * 100
+            }));
+            // Check memory thresholds
+            if (memoryUsage >= finalThresholds.memory.critical && callbacks.onMemoryWarning) {
+                callbacks.onMemoryWarning(memoryUsage);
+            }
+        }
+    }, [finalThresholds.memory.critical, callbacks.onMemoryWarning]);
+    // Battery status monitoring
+    const updateBatteryInfo = useCallback(async () => {
+        if ('getBattery' in navigator) {
+            try {
+                const battery = await navigator.getBattery();
+                setMetrics(prev => ({
+                    ...prev,
+                    batteryLevel: battery.level,
+                    isLowPowerMode: battery.level < finalThresholds.battery.low,
+                    isCharging: battery.charging
+                }));
+                // Check battery thresholds
+                if (battery.level <= finalThresholds.battery.critical && callbacks.onBatteryLow) {
+                    callbacks.onBatteryLow(battery.level);
+                }
+            }
+            catch (error) {
+                console.warn('Battery API not available:', error);
+            }
+        }
+    }, [finalThresholds.battery.low, finalThresholds.battery.critical, callbacks.onBatteryLow]);
+    // Performance mode determination
+    const determinePerformanceMode = useCallback((fps, memoryUsage) => {
+        if (fps < finalThresholds.fps.critical || (memoryUsage && memoryUsage > finalThresholds.memory.critical)) {
+            return 'low';
+        }
+        if (fps < finalThresholds.fps.warning || (memoryUsage && memoryUsage > finalThresholds.memory.warning)) {
+            return 'medium';
+        }
+        return 'high';
+    }, [finalThresholds]);
+    // Performance throttling logic
+    const shouldThrottle = useCallback(() => {
+        const { fps, memoryPercentage, batteryLevel, isLowPowerMode } = metrics;
+        // FPS-based throttling
+        if (fps < finalThresholds.fps.critical) {
+            return { should: true, reason: 'Low FPS' };
+        }
+        // Memory-based throttling
+        if (memoryPercentage && memoryPercentage > finalThresholds.memory.critical * 100) {
+            return { should: true, reason: 'High memory usage' };
+        }
+        // Battery-based throttling
+        if (enableBatteryOptimization && (isLowPowerMode || (batteryLevel && batteryLevel < finalThresholds.battery.low))) {
+            return { should: true, reason: 'Low battery' };
+        }
+        return { should: false };
+    }, [metrics, finalThresholds, enableBatteryOptimization]);
+    // Update performance mode and throttling
+    useEffect(() => {
+        const newMode = determinePerformanceMode(metrics.fps, metrics.memoryUsage);
+        const { should: shouldThrottleNow, reason } = shouldThrottle();
         setMetrics(prev => ({
-          ...prev,
-          batteryLevel: battery.level,
-          isLowPowerMode: battery.level < finalThresholds.battery.low,
-          isCharging: battery.charging
-        }))
-
-        // Check battery thresholds
-        if (battery.level <= finalThresholds.battery.critical && callbacks.onBatteryLow) {
-          callbacks.onBatteryLow(battery.level)
+            ...prev,
+            performanceMode: newMode,
+            throttlingEnabled: enableThrottling && shouldThrottleNow,
+            throttlingReason: reason
+        }));
+        // Notify callbacks
+        if (newMode !== metrics.performanceMode && callbacks.onPerformanceModeChange) {
+            callbacks.onPerformanceModeChange(newMode);
         }
-      } catch (error) {
-        console.warn('Battery API not available:', error)
-      }
-    }
-  }, [finalThresholds.battery.low, finalThresholds.battery.critical, callbacks.onBatteryLow])
-
-  // Performance mode determination
-  const determinePerformanceMode = useCallback((fps: number, memoryUsage?: number): PerformanceMetrics['performanceMode'] => {
-    if (fps < finalThresholds.fps.critical || (memoryUsage && memoryUsage > finalThresholds.memory.critical)) {
-      return 'low'
-    }
-    if (fps < finalThresholds.fps.warning || (memoryUsage && memoryUsage > finalThresholds.memory.warning)) {
-      return 'medium'
-    }
-    return 'high'
-  }, [finalThresholds])
-
-  // Performance throttling logic
-  const shouldThrottle = useCallback((): { should: boolean; reason?: string } => {
-    const { fps, memoryPercentage, batteryLevel, isLowPowerMode } = metrics
-    
-    // FPS-based throttling
-    if (fps < finalThresholds.fps.critical) {
-      return { should: true, reason: 'Low FPS' }
-    }
-    
-    // Memory-based throttling
-    if (memoryPercentage && memoryPercentage > finalThresholds.memory.critical * 100) {
-      return { should: true, reason: 'High memory usage' }
-    }
-    
-    // Battery-based throttling
-    if (enableBatteryOptimization && (isLowPowerMode || (batteryLevel && batteryLevel < finalThresholds.battery.low))) {
-      return { should: true, reason: 'Low battery' }
-    }
-    
-    return { should: false }
-  }, [metrics, finalThresholds, enableBatteryOptimization])
-
-  // Update performance mode and throttling
-  useEffect(() => {
-    const newMode = determinePerformanceMode(metrics.fps, metrics.memoryUsage)
-    const { should: shouldThrottleNow, reason } = shouldThrottle()
-    
-    setMetrics(prev => ({
-      ...prev,
-      performanceMode: newMode,
-      throttlingEnabled: enableThrottling && shouldThrottleNow,
-      throttlingReason: reason
-    }))
-
-    // Notify callbacks
-    if (newMode !== metrics.performanceMode && callbacks.onPerformanceModeChange) {
-      callbacks.onPerformanceModeChange(newMode)
-    }
-
-    if (enableThrottling && shouldThrottleNow !== metrics.throttlingEnabled && callbacks.onThrottlingChange) {
-      callbacks.onThrottlingChange(shouldThrottleNow, reason)
-    }
-  }, [metrics.fps, metrics.memoryUsage, metrics.batteryLevel, metrics.isLowPowerMode, enableThrottling, determinePerformanceMode, shouldThrottle, callbacks, metrics.performanceMode, metrics.throttlingEnabled])
-
-  // Start monitoring
-  const startMonitoring = useCallback(() => {
-    if (isMonitoring) return
-
-    setIsMonitoring(true)
-    measureFrameRate()
-    
-    // Set up interval for memory and battery updates
-    intervalIdRef.current = setInterval(() => {
-      updateMemoryInfo()
-      updateBatteryInfo()
-    }, updateInterval)
-  }, [isMonitoring, measureFrameRate, updateMemoryInfo, updateBatteryInfo, updateInterval])
-
-  // Stop monitoring
-  const stopMonitoring = useCallback(() => {
-    setIsMonitoring(false)
-    
-    if (animationIdRef.current) {
-      cancelAnimationFrame(animationIdRef.current)
-    }
-    
-    if (intervalIdRef.current) {
-      clearInterval(intervalIdRef.current)
-    }
-  }, [])
-
-  // Auto-start monitoring on mount
-  useEffect(() => {
-    startMonitoring()
-    return () => stopMonitoring()
-  }, [startMonitoring, stopMonitoring])
-
-  // Performance optimization recommendations
-  const getOptimizationRecommendations = useCallback(() => {
-    const recommendations: string[] = []
-    
-    if (metrics.fps < finalThresholds.fps.warning) {
-      recommendations.push('Consider reducing animation complexity or enabling performance mode')
-    }
-    
-    if (metrics.memoryPercentage && metrics.memoryPercentage > finalThresholds.memory.warning * 100) {
-      recommendations.push('Memory usage is high - consider implementing lazy loading or cleanup')
-    }
-    
-    if (metrics.isLowPowerMode) {
-      recommendations.push('Low battery detected - performance optimizations are active')
-    }
-    
-    return recommendations
-  }, [metrics, finalThresholds])
-
-  // Throttling controls
-  const enableThrottlingMode = useCallback(() => {
-    setMetrics(prev => ({
-      ...prev,
-      throttlingEnabled: true,
-      throttlingReason: 'Manual override'
-    }))
-  }, [])
-
-  const disableThrottlingMode = useCallback(() => {
-    setMetrics(prev => ({
-      ...prev,
-      throttlingEnabled: false,
-      throttlingReason: undefined
-    }))
-  }, [])
-
-  return {
-    // Metrics
-    metrics,
-    
-    // Controls
-    startMonitoring,
-    stopMonitoring,
-    isMonitoring,
-    
-    // Throttling
-    throttlingEnabled: metrics.throttlingEnabled,
-    throttlingReason: metrics.throttlingReason,
-    enableThrottlingMode,
-    disableThrottlingMode,
-    
-    // Performance mode
-    performanceMode: metrics.performanceMode,
-    
-    // Recommendations
-    getOptimizationRecommendations,
-    
-    // Thresholds
-    thresholds: finalThresholds,
-    
-    // Raw values for advanced usage
-    fps: metrics.fps,
-    frameTime: metrics.frameTime,
-    memoryUsage: metrics.memoryUsage,
-    batteryLevel: metrics.batteryLevel,
-    isLowPowerMode: metrics.isLowPowerMode
-  }
-}
+        if (enableThrottling && shouldThrottleNow !== metrics.throttlingEnabled && callbacks.onThrottlingChange) {
+            callbacks.onThrottlingChange(shouldThrottleNow, reason);
+        }
+    }, [metrics.fps, metrics.memoryUsage, metrics.batteryLevel, metrics.isLowPowerMode, enableThrottling, determinePerformanceMode, shouldThrottle, callbacks, metrics.performanceMode, metrics.throttlingEnabled]);
+    // Start monitoring
+    const startMonitoring = useCallback(() => {
+        if (isMonitoring)
+            return;
+        setIsMonitoring(true);
+        measureFrameRate();
+        // Set up interval for memory and battery updates
+        intervalIdRef.current = setInterval(() => {
+            updateMemoryInfo();
+            updateBatteryInfo();
+        }, updateInterval);
+    }, [isMonitoring, measureFrameRate, updateMemoryInfo, updateBatteryInfo, updateInterval]);
+    // Stop monitoring
+    const stopMonitoring = useCallback(() => {
+        setIsMonitoring(false);
+        if (animationIdRef.current) {
+            cancelAnimationFrame(animationIdRef.current);
+        }
+        if (intervalIdRef.current) {
+            clearInterval(intervalIdRef.current);
+        }
+    }, []);
+    // Auto-start monitoring on mount
+    useEffect(() => {
+        startMonitoring();
+        return () => stopMonitoring();
+    }, [startMonitoring, stopMonitoring]);
+    // Performance optimization recommendations
+    const getOptimizationRecommendations = useCallback(() => {
+        const recommendations = [];
+        if (metrics.fps < finalThresholds.fps.warning) {
+            recommendations.push('Consider reducing animation complexity or enabling performance mode');
+        }
+        if (metrics.memoryPercentage && metrics.memoryPercentage > finalThresholds.memory.warning * 100) {
+            recommendations.push('Memory usage is high - consider implementing lazy loading or cleanup');
+        }
+        if (metrics.isLowPowerMode) {
+            recommendations.push('Low battery detected - performance optimizations are active');
+        }
+        return recommendations;
+    }, [metrics, finalThresholds]);
+    // Throttling controls
+    const enableThrottlingMode = useCallback(() => {
+        setMetrics(prev => ({
+            ...prev,
+            throttlingEnabled: true,
+            throttlingReason: 'Manual override'
+        }));
+    }, []);
+    const disableThrottlingMode = useCallback(() => {
+        setMetrics(prev => ({
+            ...prev,
+            throttlingEnabled: false,
+            throttlingReason: undefined
+        }));
+    }, []);
+    return {
+        // Metrics
+        metrics,
+        // Controls
+        startMonitoring,
+        stopMonitoring,
+        isMonitoring,
+        // Throttling
+        throttlingEnabled: metrics.throttlingEnabled,
+        throttlingReason: metrics.throttlingReason,
+        enableThrottlingMode,
+        disableThrottlingMode,
+        // Performance mode
+        performanceMode: metrics.performanceMode,
+        // Recommendations
+        getOptimizationRecommendations,
+        // Thresholds
+        thresholds: finalThresholds,
+        // Raw values for advanced usage
+        fps: metrics.fps,
+        frameTime: metrics.frameTime,
+        memoryUsage: metrics.memoryUsage,
+        batteryLevel: metrics.batteryLevel,
+        isLowPowerMode: metrics.isLowPowerMode
+    };
+};