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

package/dist/hooks/use-battery-optimization.d.ts

@@ -0,0 +1,328 @@
+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 declare 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)
+        }
+      }
+    } 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

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

@@ -0,0 +1,307 @@
+import { useState, useEffect, useCallback, useRef } from 'react'
+
+export interface BatteryStatus {
+  level}
+
+export interface BatteryOptimizationConfig {
+  enableBatteryMonitoring?}
+
+export interface BatteryOptimizationCallbacks {
+  onBatteryStatusChange?) => void
+  onLowBatteryWarning?) => void
+  onCriticalBatteryWarning?) => void
+  onPerformanceThrottled?, reason) => void
+  onOptimizationApplied?) => void
+}
+
+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<BatteryStatus>({
+    level,
+    charging,
+    chargingTime,
+    dischargingTime,
+    isLow,
+    isCritical})
+  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 ()=> {
+    if (!enableBatteryMonitoring || !('getBattery' in navigator)) return null
+
+    try {
+      const battery = await (navigator as any).getBattery()
+      batteryRef.current = battery
+      
+      const status= {
+        level,
+        charging,
+        chargingTime,
+        dischargingTime,
+        isLow= lowBatteryThreshold,
+        isCritical= 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) => {
+    if (!enablePerformanceThrottling) return
+
+    setIsOptimizing(true)
+    setCurrentThrottleLevel(level)
+    
+    setTimeout(() => {
+      let optimizations] = []
+      
+      switch (level) {
+        case 'light'= [
+            'Light performance throttling applied',
+            'Animation complexity reduced by 20%',
+            'Hardware acceleration optimized for battery'
+          ]
+          break
+        case 'moderate'= [
+            'Moderate performance throttling applied',
+            'Animation complexity reduced by 40%',
+            'GPU utilization limited for battery efficiency',
+            'Non-essential animations disabled'
+          ]
+          break
+        case 'aggressive'= [
+            'Aggressive performance throttling applied',
+            'Animation complexity reduced by 70%',
+            'Hardware acceleration minimized',
+            'Only essential animations enabled',
+            'Background processes optimized'
+          ]
+          break
+        default= ['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)
+        optimizations.push('All non-essential features disabled')
+        optimizations.push('Hardware acceleration completely disabled')
+        applyPerformanceThrottling('aggressive')
+      } else if (batteryStatus.isLow) {
+        optimizations.push('Low battery mode)
+        optimizations.push('Performance throttling applied')
+        optimizations.push('Hardware acceleration optimized for battery')
+        applyPerformanceThrottling('moderate')
+      } else if (batteryStatus.level < 0.5) {
+        optimizations.push('Medium battery)
+        optimizations.push('Hardware acceleration optimized')
+        applyPerformanceThrottling('light')
+      } else {
+        optimizations.push('High battery)
+        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'= [
+          'User preference,
+          'Hardware acceleration at maximum',
+          'Battery optimization disabled'
+        ]
+        applyPerformanceThrottling('none')
+        break
+      case 'balanced'= [
+          'User preference,
+          'Hardware acceleration optimized',
+          'Battery and performance balanced'
+        ]
+        applyPerformanceThrottling('light')
+        break
+      case 'battery'= [
+          'User preference,
+          '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)
+      recommendations.push('Reduce screen brightness and disable animations')
+      recommendations.push('Close unnecessary applications and tabs')
+    } else if (batteryStatus.isLow) {
+      recommendations.push('Low battery)
+      recommendations.push('Reduce animation complexity and GPU usage')
+      recommendations.push('Optimize background processes')
+    } else if (batteryStatus.level < 0.5) {
+      recommendations.push('Medium battery)
+      recommendations.push('Monitor hardware acceleration usage')
+      recommendations.push('Balance performance and battery life')
+    } else {
+      recommendations.push('High battery)
+      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,
+    isCriticalBattery,
+    batteryPercentage),
+    optimizationRecommendations),
+    isCharging,
+    estimatedTimeRemaining,
+    
+    // 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