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

package/dist/hooks/use-battery-conscious-loading.esm.js

@@ -1,475 +1,381 @@
-import { useState, useCallback, useRef, useEffect } from 'react'
-
-export interface BatteryConsciousLoadingConfig {
-  enableBatteryMonitoring?: boolean
-  enableLoadingOptimization?: boolean
-  enablePerformanceAdjustment?: boolean
-  enableUserNotification?: boolean
-  enableAutoOptimization?: boolean
-  batteryThresholds?: {
-    critical: number
-    low: number
-    medium: number
-    high: number
-  }
-
-}
-
-export interface BatteryState {
-  level: number
-  charging: boolean
-  chargingTime: number
-  dischargingTime: number
-  status: 'critical' | 'low' | 'medium' | 'high' | 'full'
-}
-
-export interface LoadingOptimization {
-  id: string
-  name: string
-  type: 'battery' | 'performance' | 'animation' | 'memory'
-  applied: boolean
-  impact: 'low' | 'medium' | 'high'
-  description: string
-  batterySavings: number
-}
-
-export interface BatteryConsciousLoadingCallbacks {
-  onBatteryLevelChanged?: (batteryState: BatteryState) => void
-  onLoadingOptimized?: (optimization: LoadingOptimization) => void
-  onPerformanceAdjusted?: (adjustment: string) => void
-  onUserNotified?: (notification: string) => void
-}
-
-export const useBatteryConsciousLoading = (
-  config: BatteryConsciousLoadingConfig = {},
-  callbacks: BatteryConsciousLoadingCallbacks = {}
-) => {
-  const {
-    enableBatteryMonitoring = true,
-    enableLoadingOptimization = true,
-    enablePerformanceAdjustment = true,
-    enableUserNotification = true,
-    enableAutoOptimization = true,
-    batteryThresholds = {
-      critical: 0.1,
-      low: 0.3,
-      medium: 0.7,
-      high: 0.9
-    },
-
-  } = config
-
-  const [batteryState, setBatteryState] = useState<BatteryState>({
-    level: 1,
-    charging: false,
-    chargingTime: 0,
-    dischargingTime: 0,
-    status: 'full'
-  })
-
-  const [loadingOptimizations, setLoadingOptimizations] = useState<LoadingOptimization[]>([])
-  const [isOptimizing, setIsOptimizing] = useState(false)
-  const [performanceMode, setPerformanceMode] = useState<'minimal' | 'balanced' | 'full'>('full')
-  const [batterySavings, setBatterySavings] = useState(0)
-  const [notifications, setNotifications] = useState<string[]>([])
-
-  const batteryCheckRef = useRef<number | null>(null)
-  const optimizationTimerRef = useRef<number | null>(null)
-  const notificationTimerRef = useRef<number | null>(null)
-
-  // Battery monitoring
-  const startBatteryMonitoring = useCallback(() => {
-    if (!enableBatteryMonitoring) return () => {}
-
-    const checkBattery = async () => {
-      try {
-        if ('getBattery' in navigator) {
-          const battery = await (navigator as any).getBattery()
-          const level = battery.level
-          const charging = battery.charging
-          const chargingTime = battery.chargingTime || 0
-          const dischargingTime = battery.dischargingTime || 0
-          
-          let status: 'critical' | 'low' | 'medium' | 'high' | 'full'
-          if (level <= batteryThresholds.critical) status = 'critical'
-          else if (level <= batteryThresholds.low) status = 'low'
-          else if (level <= batteryThresholds.medium) status = 'medium'
-          else if (level <= batteryThresholds.high) status = 'high'
-          else status = 'full'
-          
-          const newBatteryState: BatteryState = {
-            level,
-            charging,
-            chargingTime,
-            dischargingTime,
-            status
-          }
-          
-          setBatteryState(newBatteryState)
-          callbacks.onBatteryLevelChanged?.(newBatteryState)
-          
-          // Auto-optimize based on battery level
-          if (enableAutoOptimization) {
-            autoOptimizeForBattery(newBatteryState)
-          }
-        }
-      } catch (error) {
-        console.warn('Battery monitoring failed:', error)
-      }
-    }
-    
-    // Initial check
-    checkBattery()
-    
-    // Set up periodic checking
-    batteryCheckRef.current = window.setInterval(checkBattery, 10000)
-    
-    return () => {
-      if (batteryCheckRef.current) {
-        clearInterval(batteryCheckRef.current)
-      }
-    }
-  }, [enableBatteryMonitoring, batteryThresholds, enableAutoOptimization, callbacks])
-
-  // Auto-optimize for battery level
-  const autoOptimizeForBattery = useCallback((batteryState: BatteryState) => {
-    if (!enableLoadingOptimization) return
-
-    setIsOptimizing(true)
-    
-    setTimeout(() => {
-      let newPerformanceMode: 'minimal' | 'balanced' | 'full'
-      let optimizations: LoadingOptimization[] = []
-      let savings = 0
-      
-      switch (batteryState.status) {
-        case 'critical':
-          newPerformanceMode = 'minimal'
-          optimizations = [
-            {
-              id: 'battery-critical-1',
-              name: 'Critical Battery Mode',
-              type: 'battery',
-              applied: true,
-              impact: 'high',
-              description: 'Minimal loading animations and reduced complexity for critical battery',
-              batterySavings: 40
-            },
-            {
-              id: 'battery-critical-2',
-              name: 'Ultra-Low Power Loading',
-              type: 'performance',
-              applied: true,
-              impact: 'high',
-              description: 'Ultra-low power loading states with minimal visual effects',
-              batterySavings: 35
+import { useState, useCallback, useRef, useEffect } from 'react';
+export const useBatteryConsciousLoading = (config = {}, callbacks = {}) => {
+    const { enableBatteryMonitoring = true, enableLoadingOptimization = true, enablePerformanceAdjustment = true, enableUserNotification = true, enableAutoOptimization = true, batteryThresholds = {
+        critical: 0.1,
+        low: 0.3,
+        medium: 0.7,
+        high: 0.9
+    }, } = config;
+    const [batteryState, setBatteryState] = useState({
+        level: 1,
+        charging: false,
+        chargingTime: 0,
+        dischargingTime: 0,
+        status: 'full'
+    });
+    const [loadingOptimizations, setLoadingOptimizations] = useState([]);
+    const [isOptimizing, setIsOptimizing] = useState(false);
+    const [performanceMode, setPerformanceMode] = useState('full');
+    const [batterySavings, setBatterySavings] = useState(0);
+    const [notifications, setNotifications] = useState([]);
+    const batteryCheckRef = useRef(null);
+    const optimizationTimerRef = useRef(null);
+    const notificationTimerRef = useRef(null);
+    // Battery monitoring
+    const startBatteryMonitoring = useCallback(() => {
+        if (!enableBatteryMonitoring)
+            return () => { };
+        const checkBattery = async () => {
+            try {
+                if ('getBattery' in navigator) {
+                    const battery = await navigator.getBattery();
+                    const level = battery.level;
+                    const charging = battery.charging;
+                    const chargingTime = battery.chargingTime || 0;
+                    const dischargingTime = battery.dischargingTime || 0;
+                    let status;
+                    if (level <= batteryThresholds.critical)
+                        status = 'critical';
+                    else if (level <= batteryThresholds.low)
+                        status = 'low';
+                    else if (level <= batteryThresholds.medium)
+                        status = 'medium';
+                    else if (level <= batteryThresholds.high)
+                        status = 'high';
+                    else
+                        status = 'full';
+                    const newBatteryState = {
+                        level,
+                        charging,
+                        chargingTime,
+                        dischargingTime,
+                        status
+                    };
+                    setBatteryState(newBatteryState);
+                    callbacks.onBatteryLevelChanged?.(newBatteryState);
+                    // Auto-optimize based on battery level
+                    if (enableAutoOptimization) {
+                        autoOptimizeForBattery(newBatteryState);
+                    }
+                }
+            }
+            catch (error) {
+                console.warn('Battery monitoring failed:', error);
+            }
+        };
+        // Initial check
+        checkBattery();
+        // Set up periodic checking
+        batteryCheckRef.current = window.setInterval(checkBattery, 10000);
+        return () => {
+            if (batteryCheckRef.current) {
+                clearInterval(batteryCheckRef.current);
+            }
+        };
+    }, [enableBatteryMonitoring, batteryThresholds, enableAutoOptimization, callbacks]);
+    // Auto-optimize for battery level
+    const autoOptimizeForBattery = useCallback((batteryState) => {
+        if (!enableLoadingOptimization)
+            return;
+        setIsOptimizing(true);
+        setTimeout(() => {
+            let newPerformanceMode;
+            let optimizations = [];
+            let savings = 0;
+            switch (batteryState.status) {
+                case 'critical':
+                    newPerformanceMode = 'minimal';
+                    optimizations = [
+                        {
+                            id: 'battery-critical-1',
+                            name: 'Critical Battery Mode',
+                            type: 'battery',
+                            applied: true,
+                            impact: 'high',
+                            description: 'Minimal loading animations and reduced complexity for critical battery',
+                            batterySavings: 40
+                        },
+                        {
+                            id: 'battery-critical-2',
+                            name: 'Ultra-Low Power Loading',
+                            type: 'performance',
+                            applied: true,
+                            impact: 'high',
+                            description: 'Ultra-low power loading states with minimal visual effects',
+                            batterySavings: 35
+                        }
+                    ];
+                    savings = 75;
+                    break;
+                case 'low':
+                    newPerformanceMode = 'minimal';
+                    optimizations = [
+                        {
+                            id: 'battery-low-1',
+                            name: 'Low Battery Mode',
+                            type: 'battery',
+                            applied: true,
+                            impact: 'medium',
+                            description: 'Reduced loading animations and optimized performance for low battery',
+                            batterySavings: 25
+                        },
+                        {
+                            id: 'battery-low-2',
+                            name: 'Efficient Loading States',
+                            type: 'animation',
+                            applied: true,
+                            impact: 'medium',
+                            description: 'Efficient loading states with minimal battery impact',
+                            batterySavings: 20
+                        }
+                    ];
+                    savings = 45;
+                    break;
+                case 'medium':
+                    newPerformanceMode = 'balanced';
+                    optimizations = [
+                        {
+                            id: 'battery-medium-1',
+                            name: 'Balanced Battery Mode',
+                            type: 'battery',
+                            applied: true,
+                            impact: 'low',
+                            description: 'Balanced loading animations with moderate battery optimization',
+                            batterySavings: 15
+                        }
+                    ];
+                    savings = 15;
+                    break;
+                case 'high':
+                case 'full':
+                    newPerformanceMode = 'full';
+                    optimizations = [
+                        {
+                            id: 'battery-high-1',
+                            name: 'Full Performance Mode',
+                            type: 'battery',
+                            applied: true,
+                            impact: 'low',
+                            description: 'Full loading animations with minimal battery restrictions',
+                            batterySavings: 5
+                        }
+                    ];
+                    savings = 5;
+                    break;
+            }
+            setPerformanceMode(newPerformanceMode);
+            setLoadingOptimizations(prev => [...prev, ...optimizations]);
+            setBatterySavings(savings);
+            setIsOptimizing(false);
+            // Notify user if enabled
+            if (enableUserNotification) {
+                const notification = `Battery optimization applied: ${newPerformanceMode} mode with ${savings}% battery savings`;
+                setNotifications(prev => [...prev, notification]);
+                callbacks.onUserNotified?.(notification);
             }
-          ]
-          savings = 75
-          break
-          
-        case 'low':
-          newPerformanceMode = 'minimal'
-          optimizations = [
-            {
-              id: 'battery-low-1',
-              name: 'Low Battery Mode',
-              type: 'battery',
-              applied: true,
-              impact: 'medium',
-              description: 'Reduced loading animations and optimized performance for low battery',
-              batterySavings: 25
-            },
-            {
-              id: 'battery-low-2',
-              name: 'Efficient Loading States',
-              type: 'animation',
-              applied: true,
-              impact: 'medium',
-              description: 'Efficient loading states with minimal battery impact',
-              batterySavings: 20
+            // Apply optimizations
+            optimizations.forEach(optimization => {
+                callbacks.onLoadingOptimized?.(optimization);
+            });
+            // Adjust performance
+            if (enablePerformanceAdjustment) {
+                const adjustment = `Performance adjusted to ${newPerformanceMode} mode for battery optimization`;
+                callbacks.onPerformanceAdjusted?.(adjustment);
             }
-          ]
-          savings = 45
-          break
-          
-        case 'medium':
-          newPerformanceMode = 'balanced'
-          optimizations = [
-            {
-              id: 'battery-medium-1',
-              name: 'Balanced Battery Mode',
-              type: 'battery',
-              applied: true,
-              impact: 'low',
-              description: 'Balanced loading animations with moderate battery optimization',
-              batterySavings: 15
+        }, 200);
+    }, [enableLoadingOptimization, enableUserNotification, enablePerformanceAdjustment, callbacks]);
+    // Manual loading optimization
+    const optimizeLoadingForBattery = useCallback(() => {
+        if (!enableLoadingOptimization)
+            return;
+        setIsOptimizing(true);
+        setTimeout(() => {
+            const manualOptimizations = [
+                {
+                    id: 'manual-battery-1',
+                    name: 'Manual Battery Optimization',
+                    type: 'battery',
+                    applied: true,
+                    impact: 'medium',
+                    description: 'Manually applied battery-conscious loading optimization',
+                    batterySavings: 20
+                },
+                {
+                    id: 'manual-performance-1',
+                    name: 'Performance Adjustment',
+                    type: 'performance',
+                    applied: true,
+                    impact: 'medium',
+                    description: 'Performance adjusted for optimal battery usage',
+                    batterySavings: 15
+                }
+            ];
+            setLoadingOptimizations(prev => [...prev, ...manualOptimizations]);
+            setBatterySavings(prev => prev + 35);
+            setIsOptimizing(false);
+            manualOptimizations.forEach(optimization => {
+                callbacks.onLoadingOptimized?.(optimization);
+            });
+            if (enableUserNotification) {
+                const notification = 'Manual battery optimization applied with 35% additional savings';
+                setNotifications(prev => [...prev, notification]);
+                callbacks.onUserNotified?.(notification);
             }
-          ]
-          savings = 15
-          break
-          
-        case 'high':
-        case 'full':
-          newPerformanceMode = 'full'
-          optimizations = [
-            {
-              id: 'battery-high-1',
-              name: 'Full Performance Mode',
-              type: 'battery',
-              applied: true,
-              impact: 'low',
-              description: 'Full loading animations with minimal battery restrictions',
-              batterySavings: 5
+        }, 300);
+    }, [enableLoadingOptimization, enableUserNotification, callbacks]);
+    // Memory optimization for battery
+    const optimizeMemoryForBattery = useCallback(() => {
+        if (!enableLoadingOptimization)
+            return;
+        setIsOptimizing(true);
+        setTimeout(() => {
+            const memoryOptimizations = [
+                {
+                    id: 'memory-battery-1',
+                    name: 'Memory Optimization for Battery',
+                    type: 'memory',
+                    applied: true,
+                    impact: 'medium',
+                    description: 'Memory usage optimized to reduce battery consumption',
+                    batterySavings: 10
+                },
+                {
+                    id: 'memory-battery-2',
+                    name: 'Efficient Memory Management',
+                    type: 'memory',
+                    applied: true,
+                    impact: 'low',
+                    description: 'Efficient memory management for battery-conscious loading',
+                    batterySavings: 8
+                }
+            ];
+            setLoadingOptimizations(prev => [...prev, ...memoryOptimizations]);
+            setBatterySavings(prev => prev + 18);
+            setIsOptimizing(false);
+            memoryOptimizations.forEach(optimization => {
+                callbacks.onLoadingOptimized?.(optimization);
+            });
+            if (enableUserNotification) {
+                const notification = 'Memory optimization applied with 18% additional battery savings';
+                setNotifications(prev => [...prev, notification]);
+                callbacks.onUserNotified?.(notification);
             }
-          ]
-          savings = 5
-          break
-      }
-      
-      setPerformanceMode(newPerformanceMode)
-      setLoadingOptimizations(prev => [...prev, ...optimizations])
-      setBatterySavings(savings)
-      setIsOptimizing(false)
-      
-      // Notify user if enabled
-      if (enableUserNotification) {
-        const notification = `Battery optimization applied: ${newPerformanceMode} mode with ${savings}% battery savings`
-        setNotifications(prev => [...prev, notification])
-        callbacks.onUserNotified?.(notification)
-      }
-      
-      // Apply optimizations
-      optimizations.forEach(optimization => {
-        callbacks.onLoadingOptimized?.(optimization)
-      })
-      
-      // Adjust performance
-      if (enablePerformanceAdjustment) {
-        const adjustment = `Performance adjusted to ${newPerformanceMode} mode for battery optimization`
-        callbacks.onPerformanceAdjusted?.(adjustment)
-      }
-      
-    }, 200)
-  }, [enableLoadingOptimization, enableUserNotification, enablePerformanceAdjustment, callbacks])
-
-  // Manual loading optimization
-  const optimizeLoadingForBattery = useCallback(() => {
-    if (!enableLoadingOptimization) return
-
-    setIsOptimizing(true)
-    
-    setTimeout(() => {
-      const manualOptimizations: LoadingOptimization[] = [
-        {
-          id: 'manual-battery-1',
-          name: 'Manual Battery Optimization',
-          type: 'battery',
-          applied: true,
-          impact: 'medium',
-          description: 'Manually applied battery-conscious loading optimization',
-          batterySavings: 20
-        },
-        {
-          id: 'manual-performance-1',
-          name: 'Performance Adjustment',
-          type: 'performance',
-          applied: true,
-          impact: 'medium',
-          description: 'Performance adjusted for optimal battery usage',
-          batterySavings: 15
+        }, 250);
+    }, [enableLoadingOptimization, enableUserNotification, callbacks]);
+    // Animation optimization for battery
+    const optimizeAnimationsForBattery = useCallback(() => {
+        if (!enableLoadingOptimization)
+            return;
+        setIsOptimizing(true);
+        setTimeout(() => {
+            const animationOptimizations = [
+                {
+                    id: 'animation-battery-1',
+                    name: 'Battery-Conscious Animations',
+                    type: 'animation',
+                    applied: true,
+                    impact: 'high',
+                    description: 'Animations optimized for minimal battery impact',
+                    batterySavings: 25
+                },
+                {
+                    id: 'animation-battery-2',
+                    name: 'Reduced Animation Complexity',
+                    type: 'animation',
+                    applied: true,
+                    impact: 'medium',
+                    description: 'Animation complexity reduced for battery optimization',
+                    batterySavings: 20
+                }
+            ];
+            setLoadingOptimizations(prev => [...prev, ...animationOptimizations]);
+            setBatterySavings(prev => prev + 45);
+            setIsOptimizing(false);
+            animationOptimizations.forEach(optimization => {
+                callbacks.onLoadingOptimized?.(optimization);
+            });
+            if (enableUserNotification) {
+                const notification = 'Animation optimization applied with 45% additional battery savings';
+                setNotifications(prev => [...prev, notification]);
+                callbacks.onUserNotified?.(notification);
+            }
+        }, 200);
+    }, [enableLoadingOptimization, enableUserNotification, callbacks]);
+    // Get battery-aware loading recommendations
+    const getBatteryLoadingRecommendations = useCallback(() => {
+        const recommendations = [];
+        if (batteryState.status === 'critical') {
+            recommendations.push('Use minimal loading animations to preserve battery');
+            recommendations.push('Disable non-essential visual effects');
+            recommendations.push('Consider static loading indicators');
+        }
+        else if (batteryState.status === 'low') {
+            recommendations.push('Reduce animation complexity for better battery life');
+            recommendations.push('Use efficient loading patterns');
+            recommendations.push('Optimize memory usage during loading');
         }
-      ]
-      
-      setLoadingOptimizations(prev => [...prev, ...manualOptimizations])
-      setBatterySavings(prev => prev + 35)
-      setIsOptimizing(false)
-      
-      manualOptimizations.forEach(optimization => {
-        callbacks.onLoadingOptimized?.(optimization)
-      })
-      
-      if (enableUserNotification) {
-        const notification = 'Manual battery optimization applied with 35% additional savings'
-        setNotifications(prev => [...prev, notification])
-        callbacks.onUserNotified?.(notification)
-      }
-      
-    }, 300)
-  }, [enableLoadingOptimization, enableUserNotification, callbacks])
-
-  // Memory optimization for battery
-  const optimizeMemoryForBattery = useCallback(() => {
-    if (!enableLoadingOptimization) return
-
-    setIsOptimizing(true)
-    
-    setTimeout(() => {
-      const memoryOptimizations: LoadingOptimization[] = [
-        {
-          id: 'memory-battery-1',
-          name: 'Memory Optimization for Battery',
-          type: 'memory',
-          applied: true,
-          impact: 'medium',
-          description: 'Memory usage optimized to reduce battery consumption',
-          batterySavings: 10
-        },
-        {
-          id: 'memory-battery-2',
-          name: 'Efficient Memory Management',
-          type: 'memory',
-          applied: true,
-          impact: 'low',
-          description: 'Efficient memory management for battery-conscious loading',
-          batterySavings: 8
+        else if (batteryState.status === 'medium') {
+            recommendations.push('Balance performance and battery consumption');
+            recommendations.push('Use moderate animation complexity');
+            recommendations.push('Monitor battery impact of loading states');
         }
-      ]
-      
-      setLoadingOptimizations(prev => [...prev, ...memoryOptimizations])
-      setBatterySavings(prev => prev + 18)
-      setIsOptimizing(false)
-      
-      memoryOptimizations.forEach(optimization => {
-        callbacks.onLoadingOptimized?.(optimization)
-      })
-      
-      if (enableUserNotification) {
-        const notification = 'Memory optimization applied with 18% additional battery savings'
-        setNotifications(prev => [...prev, notification])
-        callbacks.onUserNotified?.(notification)
-      }
-      
-    }, 250)
-  }, [enableLoadingOptimization, enableUserNotification, callbacks])
-
-  // Animation optimization for battery
-  const optimizeAnimationsForBattery = useCallback(() => {
-    if (!enableLoadingOptimization) return
-
-    setIsOptimizing(true)
-    
-    setTimeout(() => {
-      const animationOptimizations: LoadingOptimization[] = [
-        {
-          id: 'animation-battery-1',
-          name: 'Battery-Conscious Animations',
-          type: 'animation',
-          applied: true,
-          impact: 'high',
-          description: 'Animations optimized for minimal battery impact',
-          batterySavings: 25
-        },
-        {
-          id: 'animation-battery-2',
-          name: 'Reduced Animation Complexity',
-          type: 'animation',
-          applied: true,
-          impact: 'medium',
-          description: 'Animation complexity reduced for battery optimization',
-          batterySavings: 20
+        else {
+            recommendations.push('Full performance mode available');
+            recommendations.push('Rich loading animations supported');
+            recommendations.push('Monitor for battery optimization opportunities');
         }
-      ]
-      
-      setLoadingOptimizations(prev => [...prev, ...animationOptimizations])
-      setBatterySavings(prev => prev + 45)
-      setIsOptimizing(false)
-      
-      animationOptimizations.forEach(optimization => {
-        callbacks.onLoadingOptimized?.(optimization)
-      })
-      
-      if (enableUserNotification) {
-        const notification = 'Animation optimization applied with 45% additional battery savings'
-        setNotifications(prev => [...prev, notification])
-        callbacks.onUserNotified?.(notification)
-      }
-      
-    }, 200)
-  }, [enableLoadingOptimization, enableUserNotification, callbacks])
-
-  // Get battery-aware loading recommendations
-  const getBatteryLoadingRecommendations = useCallback(() => {
-    const recommendations: string[] = []
-    
-    if (batteryState.status === 'critical') {
-      recommendations.push('Use minimal loading animations to preserve battery')
-      recommendations.push('Disable non-essential visual effects')
-      recommendations.push('Consider static loading indicators')
-    } else if (batteryState.status === 'low') {
-      recommendations.push('Reduce animation complexity for better battery life')
-      recommendations.push('Use efficient loading patterns')
-      recommendations.push('Optimize memory usage during loading')
-    } else if (batteryState.status === 'medium') {
-      recommendations.push('Balance performance and battery consumption')
-      recommendations.push('Use moderate animation complexity')
-      recommendations.push('Monitor battery impact of loading states')
-    } else {
-      recommendations.push('Full performance mode available')
-      recommendations.push('Rich loading animations supported')
-      recommendations.push('Monitor for battery optimization opportunities')
-    }
-    
-    return recommendations
-  }, [batteryState.status])
-
-  // Clear optimizations
-  const clearOptimizations = useCallback(() => {
-    setLoadingOptimizations([])
-    setBatterySavings(0)
-    setNotifications([])
-  }, [])
-
-  // Initialize battery monitoring
-  useEffect(() => {
-    const stopBatteryMonitoring = startBatteryMonitoring()
-    
-    return () => {
-      stopBatteryMonitoring()
-    }
-  }, [startBatteryMonitoring])
-
-  // Cleanup on unmount
-  useEffect(() => {
-    return () => {
-      if (batteryCheckRef.current) {
-        clearInterval(batteryCheckRef.current)
-      }
-      if (optimizationTimerRef.current) {
-        clearTimeout(optimizationTimerRef.current)
-      }
-      if (notificationTimerRef.current) {
-        clearTimeout(notificationTimerRef.current)
-      }
-    }
-  }, [])
-
-  return {
-    // State
-    batteryState,
-    loadingOptimizations,
-    isOptimizing,
-    performanceMode,
-    batterySavings,
-    notifications,
-    
-    // Functions
-    optimizeLoadingForBattery,
-    optimizeMemoryForBattery,
-    optimizeAnimationsForBattery,
-    autoOptimizeForBattery,
-    
-    // Utility functions
-    isBatteryCritical: () => batteryState.status === 'critical',
-    isBatteryLow: () => batteryState.status === 'low',
-    isBatteryOptimized: () => batterySavings > 0,
-    getBatteryPercentage: () => Math.round(batteryState.level * 100),
-    getBatteryStatus: () => batteryState.status,
-    getPerformanceMode: () => performanceMode,
-    getBatterySavings: () => batterySavings,
-    getBatteryLoadingRecommendations,
-    clearOptimizations
-  }
-}
-
-export default useBatteryConsciousLoading
+        return recommendations;
+    }, [batteryState.status]);
+    // Clear optimizations
+    const clearOptimizations = useCallback(() => {
+        setLoadingOptimizations([]);
+        setBatterySavings(0);
+        setNotifications([]);
+    }, []);
+    // Initialize battery monitoring
+    useEffect(() => {
+        const stopBatteryMonitoring = startBatteryMonitoring();
+        return () => {
+            stopBatteryMonitoring();
+        };
+    }, [startBatteryMonitoring]);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            if (batteryCheckRef.current) {
+                clearInterval(batteryCheckRef.current);
+            }
+            if (optimizationTimerRef.current) {
+                clearTimeout(optimizationTimerRef.current);
+            }
+            if (notificationTimerRef.current) {
+                clearTimeout(notificationTimerRef.current);
+            }
+        };
+    }, []);
+    return {
+        // State
+        batteryState,
+        loadingOptimizations,
+        isOptimizing,
+        performanceMode,
+        batterySavings,
+        notifications,
+        // Functions
+        optimizeLoadingForBattery,
+        optimizeMemoryForBattery,
+        optimizeAnimationsForBattery,
+        autoOptimizeForBattery,
+        // Utility functions
+        isBatteryCritical: () => batteryState.status === 'critical',
+        isBatteryLow: () => batteryState.status === 'low',
+        isBatteryOptimized: () => batterySavings > 0,
+        getBatteryPercentage: () => Math.round(batteryState.level * 100),
+        getBatteryStatus: () => batteryState.status,
+        getPerformanceMode: () => performanceMode,
+        getBatterySavings: () => batterySavings,
+        getBatteryLoadingRecommendations,
+        clearOptimizations
+    };
+};
+export default useBatteryConsciousLoading;