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

package/dist/hooks/use-battery-optimization.js

@@ -1,330 +1,268 @@
-import { useState, useEffect, useCallback, useRef } from 'react'
-
-export interface BatteryStatus {
-  level: number
-  charging: boolean
-  chargingTime: number
-  dischargingTime: number
-  isLow: boolean
-  isCritical: boolean
-}
-
-export interface BatteryOptimizationConfig {
-  enableBatteryMonitoring?: boolean
-  enablePerformanceThrottling?: boolean
-  enableUserPreferences?: boolean
-  enableAdaptiveOptimization?: boolean
-  lowBatteryThreshold?: number
-  criticalBatteryThreshold?: number
-  performanceThrottleLevel?: 'none' | 'light' | 'moderate' | 'aggressive'
-  userPreferenceLevel?: 'performance' | 'balanced' | 'battery'
-}
-
-export interface BatteryOptimizationCallbacks {
-  onBatteryStatusChange?: (status: BatteryStatus) => void
-  onLowBatteryWarning?: (status: BatteryStatus) => void
-  onCriticalBatteryWarning?: (status: BatteryStatus) => void
-  onPerformanceThrottled?: (level: string, reason: string) => void
-  onOptimizationApplied?: (optimization: string) => void
-}
-
-export const useBatteryOptimization = (
-  config: BatteryOptimizationConfig = {},
-  callbacks: BatteryOptimizationCallbacks = {}
-) => {
-  const {
-    enableBatteryMonitoring = true,
-    enablePerformanceThrottling = true,
-    enableUserPreferences = true,
-    enableAdaptiveOptimization = true,
-    lowBatteryThreshold = 0.2,
-    criticalBatteryThreshold = 0.1,
-    userPreferenceLevel = 'balanced'
-  } = config
-
-  const [batteryStatus, setBatteryStatus] = useState<BatteryStatus>({
-    level: 1,
-    charging: false,
-    chargingTime: 0,
-    dischargingTime: 0,
-    isLow: false,
-    isCritical: false
-  })
-  const [isOptimizing, setIsOptimizing] = useState(false)
-  const [optimizations, setOptimizations] = useState<string[]>([])
-  const [currentThrottleLevel, setCurrentThrottleLevel] = useState<string>('none')
-  const [userPreferences, setUserPreferences] = useState<string>(userPreferenceLevel)
-
-  const batteryRef = useRef<any>(null)
-  const batteryCheckIntervalRef = useRef<number | null>(null)
-  const optimizationTimerRef = useRef<number | null>(null)
-
-  // Get battery status
-  const getBatteryStatus = useCallback(async (): Promise<BatteryStatus | null> => {
-    if (!enableBatteryMonitoring || !('getBattery' in navigator)) return null
-
-    try {
-      const battery = await (navigator as any).getBattery()
-      batteryRef.current = battery
-      
-      const status: BatteryStatus = {
-        level: battery.level,
-        charging: battery.charging,
-        chargingTime: battery.chargingTime,
-        dischargingTime: battery.dischargingTime,
-        isLow: battery.level <= lowBatteryThreshold,
-        isCritical: battery.level <= criticalBatteryThreshold
-      }
-      
-      setBatteryStatus(status)
-      callbacks.onBatteryStatusChange?.(status)
-      
-      // Check for warnings
-      if (status.isCritical) {
-        callbacks.onCriticalBatteryWarning?.(status)
-      } else if (status.isLow) {
-        callbacks.onLowBatteryWarning?.(status)
-      }
-      
-      return status
-    } catch (error) {
-      console.warn('Battery API not available:', error)
-      return null
-    }
-  }, [enableBatteryMonitoring, lowBatteryThreshold, criticalBatteryThreshold, callbacks])
-
-  // Apply performance throttling based on battery level
-  const applyPerformanceThrottling = useCallback((level: string) => {
-    if (!enablePerformanceThrottling) return
-
-    setIsOptimizing(true)
-    setCurrentThrottleLevel(level)
-    
-    setTimeout(() => {
-      let optimizations: string[] = []
-      
-      switch (level) {
-        case 'light':
-          optimizations = [
-            'Light performance throttling applied',
-            'Animation complexity reduced by 20%',
-            'Hardware acceleration optimized for battery'
-          ]
-          break
-        case 'moderate':
-          optimizations = [
-            'Moderate performance throttling applied',
-            'Animation complexity reduced by 40%',
-            'GPU utilization limited for battery efficiency',
-            'Non-essential animations disabled'
-          ]
-          break
-        case 'aggressive':
-          optimizations = [
-            'Aggressive performance throttling applied',
-            'Animation complexity reduced by 70%',
-            'Hardware acceleration minimized',
-            'Only essential animations enabled',
-            'Background processes optimized'
-          ]
-          break
-        default:
-          optimizations = ['Performance throttling disabled']
-      }
-      
-      setOptimizations(prev => [...prev, ...optimizations])
-      setIsOptimizing(false)
-      
-      callbacks.onPerformanceThrottled?.(level, 'Battery optimization')
-      optimizations.forEach(optimization => {
-        callbacks.onOptimizationApplied?.(optimization)
-      })
-    }, 300)
-  }, [enablePerformanceThrottling, callbacks])
-
-  // Apply battery optimizations
-  const applyBatteryOptimizations = useCallback(() => {
-    if (!enableAdaptiveOptimization) return
-
-    setIsOptimizing(true)
-    
-    setTimeout(() => {
-      const optimizations: string[] = []
-      
-      if (batteryStatus.isCritical) {
-        optimizations.push('Critical battery mode: Maximum power saving enabled')
-        optimizations.push('All non-essential features disabled')
-        optimizations.push('Hardware acceleration completely disabled')
-        applyPerformanceThrottling('aggressive')
-      } else if (batteryStatus.isLow) {
-        optimizations.push('Low battery mode: Enhanced power saving enabled')
-        optimizations.push('Performance throttling applied')
-        optimizations.push('Hardware acceleration optimized for battery')
-        applyPerformanceThrottling('moderate')
-      } else if (batteryStatus.level < 0.5) {
-        optimizations.push('Medium battery: Light optimization applied')
-        optimizations.push('Hardware acceleration optimized')
-        applyPerformanceThrottling('light')
-      } else {
-        optimizations.push('High battery: Performance mode enabled')
-        optimizations.push('Hardware acceleration at full capacity')
-        applyPerformanceThrottling('none')
-      }
-      
-      setOptimizations(prev => [...prev, ...optimizations])
-      setIsOptimizing(false)
-      
-      optimizations.forEach(optimization => {
-        callbacks.onOptimizationApplied?.(optimization)
-      })
-    }, 200)
-  }, [enableAdaptiveOptimization, batteryStatus, applyPerformanceThrottling, callbacks])
-
-  // Handle user preferences
-  const updateUserPreferences = useCallback((preference: string) => {
-    if (!enableUserPreferences) return
-
-    setUserPreferences(preference)
-    
-    let optimizations: string[] = []
-    
-    switch (preference) {
-      case 'performance':
-        optimizations = [
-          'User preference: Performance mode enabled',
-          'Hardware acceleration at maximum',
-          'Battery optimization disabled'
-        ]
-        applyPerformanceThrottling('none')
-        break
-      case 'balanced':
-        optimizations = [
-          'User preference: Balanced mode enabled',
-          'Hardware acceleration optimized',
-          'Battery and performance balanced'
-        ]
-        applyPerformanceThrottling('light')
-        break
-      case 'battery':
-        optimizations = [
-          'User preference: Battery saver mode enabled',
-          'Hardware acceleration optimized for battery',
-          'Performance throttling applied'
-        ]
-        applyPerformanceThrottling('moderate')
-        break
-    }
-    
-    setOptimizations(prev => [...prev, ...optimizations])
-    optimizations.forEach(optimization => {
-      callbacks.onOptimizationApplied?.(optimization)
-    })
-  }, [enableUserPreferences, applyPerformanceThrottling, callbacks])
-
-  // Get optimization recommendations
-  const getOptimizationRecommendations = useCallback(() => {
-    const recommendations = []
-    
-    if (batteryStatus.isCritical) {
-      recommendations.push('Critical battery: Disable all non-essential features')
-      recommendations.push('Reduce screen brightness and disable animations')
-      recommendations.push('Close unnecessary applications and tabs')
-    } else if (batteryStatus.isLow) {
-      recommendations.push('Low battery: Enable battery saver mode')
-      recommendations.push('Reduce animation complexity and GPU usage')
-      recommendations.push('Optimize background processes')
-    } else if (batteryStatus.level < 0.5) {
-      recommendations.push('Medium battery: Consider light optimizations')
-      recommendations.push('Monitor hardware acceleration usage')
-      recommendations.push('Balance performance and battery life')
-    } else {
-      recommendations.push('High battery: Full performance available')
-      recommendations.push('Hardware acceleration at maximum capacity')
-      recommendations.push('Monitor for optimal performance')
-    }
-    
-    return recommendations
-  }, [batteryStatus])
-
-  // Initialize battery monitoring
-  useEffect(() => {
-    if (!enableBatteryMonitoring) return
-
-    try {
-      // Get initial battery status
-      getBatteryStatus()
-      
-      // Set up battery monitoring interval
-      batteryCheckIntervalRef.current = window.setInterval(getBatteryStatus, 10000) // Check every 10 seconds
-      
-      return () => {
-        if (batteryCheckIntervalRef.current) {
-          clearInterval(batteryCheckIntervalRef.current)
+import { useState, useEffect, useCallback, useRef } from 'react';
+export const useBatteryOptimization = (config = {}, callbacks = {}) => {
+    const { enableBatteryMonitoring = true, enablePerformanceThrottling = true, enableUserPreferences = true, enableAdaptiveOptimization = true, lowBatteryThreshold = 0.2, criticalBatteryThreshold = 0.1, userPreferenceLevel = 'balanced' } = config;
+    const [batteryStatus, setBatteryStatus] = useState({
+        level: 1,
+        charging: false,
+        chargingTime: 0,
+        dischargingTime: 0,
+        isLow: false,
+        isCritical: false
+    });
+    const [isOptimizing, setIsOptimizing] = useState(false);
+    const [optimizations, setOptimizations] = useState([]);
+    const [currentThrottleLevel, setCurrentThrottleLevel] = useState('none');
+    const [userPreferences, setUserPreferences] = useState(userPreferenceLevel);
+    const batteryRef = useRef(null);
+    const batteryCheckIntervalRef = useRef(null);
+    const optimizationTimerRef = useRef(null);
+    // Get battery status
+    const getBatteryStatus = useCallback(async () => {
+        if (!enableBatteryMonitoring || !('getBattery' in navigator))
+            return null;
+        try {
+            const battery = await navigator.getBattery();
+            batteryRef.current = battery;
+            const status = {
+                level: battery.level,
+                charging: battery.charging,
+                chargingTime: battery.chargingTime,
+                dischargingTime: battery.dischargingTime,
+                isLow: battery.level <= lowBatteryThreshold,
+                isCritical: battery.level <= criticalBatteryThreshold
+            };
+            setBatteryStatus(status);
+            callbacks.onBatteryStatusChange?.(status);
+            // Check for warnings
+            if (status.isCritical) {
+                callbacks.onCriticalBatteryWarning?.(status);
+            }
+            else if (status.isLow) {
+                callbacks.onLowBatteryWarning?.(status);
+            }
+            return status;
         }
-      }
-    } catch (error) {
-      console.warn('Battery optimization initialization failed:', error)
-    }
-  }, [enableBatteryMonitoring, getBatteryStatus])
-
-  // Apply optimizations when battery status changes
-  useEffect(() => {
-    if (enableAdaptiveOptimization) {
-      applyBatteryOptimizations()
-    }
-  }, [enableAdaptiveOptimization, applyBatteryOptimizations])
-
-  // Set initial user preferences
-  useEffect(() => {
-    if (enableUserPreferences) {
-      updateUserPreferences(userPreferenceLevel)
-    }
-  }, [enableUserPreferences, userPreferenceLevel, updateUserPreferences])
-
-  // Cleanup on unmount
-  useEffect(() => {
-    return () => {
-      if (batteryCheckIntervalRef.current) {
-        clearInterval(batteryCheckIntervalRef.current)
-      }
-      if (optimizationTimerRef.current) {
-        clearTimeout(optimizationTimerRef.current)
-      }
-    }
-  }, [])
-
-  return {
-    // State
-    batteryStatus,
-    isOptimizing,
-    optimizations,
-    currentThrottleLevel,
-    userPreferences,
-    
-    // Actions
-    getBatteryStatus,
-    applyPerformanceThrottling,
-    applyBatteryOptimizations,
-    updateUserPreferences,
-    
-    // Computed values
-    isLowBattery: batteryStatus.isLow,
-    isCriticalBattery: batteryStatus.isCritical,
-    batteryPercentage: Math.round(batteryStatus.level * 100),
-    optimizationRecommendations: getOptimizationRecommendations(),
-    isCharging: batteryStatus.charging,
-    estimatedTimeRemaining: batteryStatus.charging ? 
-      batteryStatus.chargingTime : batteryStatus.dischargingTime,
-    
-    // Utility functions
-    getBatteryHealth: () => {
-      if (batteryStatus.level >= 0.8) return 'excellent'
-      if (batteryStatus.level >= 0.6) return 'good'
-      if (batteryStatus.level >= 0.4) return 'fair'
-      if (batteryStatus.level >= 0.2) return 'poor'
-      return 'critical'
-    }
-  }
-}
-
-export default useBatteryOptimization
+        catch (error) {
+            console.warn('Battery API not available:', error);
+            return null;
+        }
+    }, [enableBatteryMonitoring, lowBatteryThreshold, criticalBatteryThreshold, callbacks]);
+    // Apply performance throttling based on battery level
+    const applyPerformanceThrottling = useCallback((level) => {
+        if (!enablePerformanceThrottling)
+            return;
+        setIsOptimizing(true);
+        setCurrentThrottleLevel(level);
+        setTimeout(() => {
+            let optimizations = [];
+            switch (level) {
+                case 'light':
+                    optimizations = [
+                        'Light performance throttling applied',
+                        'Animation complexity reduced by 20%',
+                        'Hardware acceleration optimized for battery'
+                    ];
+                    break;
+                case 'moderate':
+                    optimizations = [
+                        'Moderate performance throttling applied',
+                        'Animation complexity reduced by 40%',
+                        'GPU utilization limited for battery efficiency',
+                        'Non-essential animations disabled'
+                    ];
+                    break;
+                case 'aggressive':
+                    optimizations = [
+                        'Aggressive performance throttling applied',
+                        'Animation complexity reduced by 70%',
+                        'Hardware acceleration minimized',
+                        'Only essential animations enabled',
+                        'Background processes optimized'
+                    ];
+                    break;
+                default:
+                    optimizations = ['Performance throttling disabled'];
+            }
+            setOptimizations(prev => [...prev, ...optimizations]);
+            setIsOptimizing(false);
+            callbacks.onPerformanceThrottled?.(level, 'Battery optimization');
+            optimizations.forEach(optimization => {
+                callbacks.onOptimizationApplied?.(optimization);
+            });
+        }, 300);
+    }, [enablePerformanceThrottling, callbacks]);
+    // Apply battery optimizations
+    const applyBatteryOptimizations = useCallback(() => {
+        if (!enableAdaptiveOptimization)
+            return;
+        setIsOptimizing(true);
+        setTimeout(() => {
+            const optimizations = [];
+            if (batteryStatus.isCritical) {
+                optimizations.push('Critical battery mode: Maximum power saving enabled');
+                optimizations.push('All non-essential features disabled');
+                optimizations.push('Hardware acceleration completely disabled');
+                applyPerformanceThrottling('aggressive');
+            }
+            else if (batteryStatus.isLow) {
+                optimizations.push('Low battery mode: Enhanced power saving enabled');
+                optimizations.push('Performance throttling applied');
+                optimizations.push('Hardware acceleration optimized for battery');
+                applyPerformanceThrottling('moderate');
+            }
+            else if (batteryStatus.level < 0.5) {
+                optimizations.push('Medium battery: Light optimization applied');
+                optimizations.push('Hardware acceleration optimized');
+                applyPerformanceThrottling('light');
+            }
+            else {
+                optimizations.push('High battery: Performance mode enabled');
+                optimizations.push('Hardware acceleration at full capacity');
+                applyPerformanceThrottling('none');
+            }
+            setOptimizations(prev => [...prev, ...optimizations]);
+            setIsOptimizing(false);
+            optimizations.forEach(optimization => {
+                callbacks.onOptimizationApplied?.(optimization);
+            });
+        }, 200);
+    }, [enableAdaptiveOptimization, batteryStatus, applyPerformanceThrottling, callbacks]);
+    // Handle user preferences
+    const updateUserPreferences = useCallback((preference) => {
+        if (!enableUserPreferences)
+            return;
+        setUserPreferences(preference);
+        let optimizations = [];
+        switch (preference) {
+            case 'performance':
+                optimizations = [
+                    'User preference: Performance mode enabled',
+                    'Hardware acceleration at maximum',
+                    'Battery optimization disabled'
+                ];
+                applyPerformanceThrottling('none');
+                break;
+            case 'balanced':
+                optimizations = [
+                    'User preference: Balanced mode enabled',
+                    'Hardware acceleration optimized',
+                    'Battery and performance balanced'
+                ];
+                applyPerformanceThrottling('light');
+                break;
+            case 'battery':
+                optimizations = [
+                    'User preference: Battery saver mode enabled',
+                    'Hardware acceleration optimized for battery',
+                    'Performance throttling applied'
+                ];
+                applyPerformanceThrottling('moderate');
+                break;
+        }
+        setOptimizations(prev => [...prev, ...optimizations]);
+        optimizations.forEach(optimization => {
+            callbacks.onOptimizationApplied?.(optimization);
+        });
+    }, [enableUserPreferences, applyPerformanceThrottling, callbacks]);
+    // Get optimization recommendations
+    const getOptimizationRecommendations = useCallback(() => {
+        const recommendations = [];
+        if (batteryStatus.isCritical) {
+            recommendations.push('Critical battery: Disable all non-essential features');
+            recommendations.push('Reduce screen brightness and disable animations');
+            recommendations.push('Close unnecessary applications and tabs');
+        }
+        else if (batteryStatus.isLow) {
+            recommendations.push('Low battery: Enable battery saver mode');
+            recommendations.push('Reduce animation complexity and GPU usage');
+            recommendations.push('Optimize background processes');
+        }
+        else if (batteryStatus.level < 0.5) {
+            recommendations.push('Medium battery: Consider light optimizations');
+            recommendations.push('Monitor hardware acceleration usage');
+            recommendations.push('Balance performance and battery life');
+        }
+        else {
+            recommendations.push('High battery: Full performance available');
+            recommendations.push('Hardware acceleration at maximum capacity');
+            recommendations.push('Monitor for optimal performance');
+        }
+        return recommendations;
+    }, [batteryStatus]);
+    // Initialize battery monitoring
+    useEffect(() => {
+        if (!enableBatteryMonitoring)
+            return;
+        try {
+            // Get initial battery status
+            getBatteryStatus();
+            // Set up battery monitoring interval
+            batteryCheckIntervalRef.current = window.setInterval(getBatteryStatus, 10000); // Check every 10 seconds
+            return () => {
+                if (batteryCheckIntervalRef.current) {
+                    clearInterval(batteryCheckIntervalRef.current);
+                }
+            };
+        }
+        catch (error) {
+            console.warn('Battery optimization initialization failed:', error);
+        }
+    }, [enableBatteryMonitoring, getBatteryStatus]);
+    // Apply optimizations when battery status changes
+    useEffect(() => {
+        if (enableAdaptiveOptimization) {
+            applyBatteryOptimizations();
+        }
+    }, [enableAdaptiveOptimization, applyBatteryOptimizations]);
+    // Set initial user preferences
+    useEffect(() => {
+        if (enableUserPreferences) {
+            updateUserPreferences(userPreferenceLevel);
+        }
+    }, [enableUserPreferences, userPreferenceLevel, updateUserPreferences]);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            if (batteryCheckIntervalRef.current) {
+                clearInterval(batteryCheckIntervalRef.current);
+            }
+            if (optimizationTimerRef.current) {
+                clearTimeout(optimizationTimerRef.current);
+            }
+        };
+    }, []);
+    return {
+        // State
+        batteryStatus,
+        isOptimizing,
+        optimizations,
+        currentThrottleLevel,
+        userPreferences,
+        // Actions
+        getBatteryStatus,
+        applyPerformanceThrottling,
+        applyBatteryOptimizations,
+        updateUserPreferences,
+        // Computed values
+        isLowBattery: batteryStatus.isLow,
+        isCriticalBattery: batteryStatus.isCritical,
+        batteryPercentage: Math.round(batteryStatus.level * 100),
+        optimizationRecommendations: getOptimizationRecommendations(),
+        isCharging: batteryStatus.charging,
+        estimatedTimeRemaining: batteryStatus.charging ?
+            batteryStatus.chargingTime : batteryStatus.dischargingTime,
+        // Utility functions
+        getBatteryHealth: () => {
+            if (batteryStatus.level >= 0.8)
+                return 'excellent';
+            if (batteryStatus.level >= 0.6)
+                return 'good';
+            if (batteryStatus.level >= 0.4)
+                return 'fair';
+            if (batteryStatus.level >= 0.2)
+                return 'poor';
+            return 'critical';
+        }
+    };
+};
+export default useBatteryOptimization;