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

package/dist/hooks/use-battery-optimization.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

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

@@ -0,0 +1,297 @@
+export interface BatteryMetrics {
+  level: number
+  charging: boolean
+  chargingTime: number
+  dischargingTime: number
+  isLowPowerMode: boolean
+  isCriticalBattery: boolean
+  performanceMode: 'high' | 'medium' | 'low'
+  throttlingEnabled: boolean
+  throttlingReason?: string
+}
+
+export interface BatteryThresholds {
+  low: number
+  critical: number
+  warning: number
+}
+
+export interface BatteryCallbacks {
+  onBatteryLow?: (level: number) => void
+  onBatteryCritical?: (level: number) => void
+  onChargingStateChange?: (charging: boolean) => void
+  onPerformanceModeChange?: (mode: BatteryMetrics['performanceMode']) => void
+  onThrottlingChange?: (enabled: boolean, reason?: string) => void
+}
+
+export interface BatteryOptions {
+  updateInterval?: number
+  thresholds?: Partial<BatteryThresholds>
+  enableThrottling?: boolean
+  callbacks?: BatteryCallbacks
+}
+
+const DEFAULT_THRESHOLDS: BatteryThresholds = {
+  low: 0.3,
+  critical: 0.15,
+  warning: 0.5
+}
+
+export declare const useBatteryStatus: (options: BatteryOptions = {}) => {
+  const {
+    updateInterval = 5000,
+    thresholds = {},
+    enableThrottling = true,
+    callbacks = {}
+  } = options
+
+  const [metrics, setMetrics] = useState<BatteryMetrics>({
+    level: 1,
+    charging: true,
+    chargingTime: 0,
+    dischargingTime: 0,
+    isLowPowerMode: false,
+    isCriticalBattery: false,
+    performanceMode: 'high',
+    throttlingEnabled: false
+  })
+
+  const [isMonitoring, setIsMonitoring] = useState(false)
+  const intervalIdRef = useRef<NodeJS.Timeout>()
+  const batteryRef = useRef<any>(null)
+
+  // Merge default thresholds with custom ones
+  const finalThresholds = useMemo(() => ({
+    ...DEFAULT_THRESHOLDS,
+    ...thresholds
+  }), [thresholds])
+
+  // Determine performance mode based on battery level
+  const determinePerformanceMode = useCallback((level: number, charging: boolean): BatteryMetrics['performanceMode'] => {
+    if (charging) return 'high'
+    if (level <= finalThresholds.critical) return 'low'
+    if (level <= finalThresholds.low) return 'medium'
+    return 'high'
+  }, [finalThresholds])
+
+  // Determine if throttling should be enabled
+  const shouldThrottle = useCallback((level: number, charging: boolean): { should: boolean; reason?: string } => {
+    if (!enableThrottling) return { should: false }
+
+    if (level <= finalThresholds.critical) {
+      return { should: true, reason: 'Critical battery level' }
+    }
+
+    if (level <= finalThresholds.low && !charging) {
+      return { should: true, reason: 'Low battery level' }
+    }
+
+    return { should: false }
+  }, [enableThrottling, finalThresholds])
+
+  // Update battery information
+  const updateBatteryInfo = useCallback(async () => {
+    if ('getBattery' in navigator) {
+      try {
+        if (!batteryRef.current) {
+          batteryRef.current = await (navigator as any).getBattery()
+        }
+
+        const battery = batteryRef.current
+        const level = battery.level
+        const charging = battery.charging
+        const chargingTime = battery.chargingTime
+        const dischargingTime = battery.dischargingTime
+
+        const isLowPowerMode = level < finalThresholds.low
+        const isCriticalBattery = level < finalThresholds.critical
+
+        // Determine performance mode
+        const performanceMode = determinePerformanceMode(level, charging)
+
+        // Determine throttling
+        const { should: shouldThrottleNow, reason } = shouldThrottle(level, charging)
+
+        const newMetrics: BatteryMetrics = {
+          level,
+          charging,
+          chargingTime,
+          dischargingTime,
+          isLowPowerMode,
+          isCriticalBattery,
+          performanceMode,
+          throttlingEnabled: shouldThrottleNow,
+          throttlingReason: reason
+        }
+
+        setMetrics(newMetrics)
+
+        // Check thresholds and call callbacks
+        if (level <= finalThresholds.critical && callbacks.onBatteryCritical) {
+          callbacks.onBatteryCritical(level)
+        } else if (level <= finalThresholds.low && callbacks.onBatteryLow) {
+          callbacks.onBatteryLow(level)
+        }
+
+        if (charging !== metrics.charging && callbacks.onChargingStateChange) {
+          callbacks.onChargingStateChange(charging)
+        }
+
+        if (performanceMode !== metrics.performanceMode && callbacks.onPerformanceModeChange) {
+          callbacks.onPerformanceModeChange(performanceMode)
+        }
+
+        if (shouldThrottleNow !== metrics.throttlingEnabled && callbacks.onThrottlingChange) {
+          callbacks.onThrottlingChange(shouldThrottleNow, reason)
+        }
+
+      } catch (error) {
+        console.warn('Battery API not available:', error)
+      }
+    }
+  }, [finalThresholds, callbacks, metrics.charging, metrics.performanceMode, metrics.throttlingEnabled, determinePerformanceMode, shouldThrottle])
+
+  // Start monitoring
+  const startMonitoring = useCallback(() => {
+    if (isMonitoring) return
+
+    setIsMonitoring(true)
+
+    // Initial battery check
+    updateBatteryInfo()
+
+    // Set up interval for battery updates
+    intervalIdRef.current = setInterval(updateBatteryInfo, updateInterval)
+  }, [isMonitoring, updateBatteryInfo, updateInterval])
+
+  // Stop monitoring
+  const stopMonitoring = useCallback(() => {
+    setIsMonitoring(false)
+
+    if (intervalIdRef.current) {
+      clearInterval(intervalIdRef.current)
+    }
+  }, [])
+
+  // Manual throttling controls
+  const enableThrottlingMode = useCallback((reason?: string) => {
+    setMetrics(prev => ({
+      ...prev,
+      throttlingEnabled: true,
+      throttlingReason: reason || 'Manual override'
+    }))
+  }, [])
+
+  const disableThrottlingMode = useCallback(() => {
+    setMetrics(prev => ({
+      ...prev,
+      throttlingEnabled: false,
+      throttlingReason: undefined
+    }))
+  }, [])
+
+  // Auto-start monitoring on mount
+  useEffect(() => {
+    startMonitoring()
+    return () => stopMonitoring()
+  }, [startMonitoring, stopMonitoring])
+
+  // Battery optimization recommendations
+  const getOptimizationRecommendations = useCallback(() => {
+    const recommendations: string[] = []
+
+    if (metrics.isCriticalBattery) {
+      recommendations.push('Critical battery level - enable maximum power saving mode')
+      recommendations.push('Reduce animation complexity and disable non-essential features')
+      recommendations.push('Consider switching to low-power theme')
+    } else if (metrics.isLowPowerMode) {
+      recommendations.push('Low battery detected - enable power saving optimizations')
+      recommendations.push('Reduce background processing and network requests')
+      recommendations.push('Optimize rendering performance')
+    }
+
+    if (metrics.throttlingEnabled) {
+      recommendations.push('Performance throttling active - adjust user experience accordingly')
+    }
+
+    if (!metrics.charging && metrics.level < 0.5) {
+      recommendations.push('Battery below 50% - consider enabling power saving features')
+    }
+
+    return recommendations
+  }, [metrics])
+
+  // Power saving suggestions
+  const getPowerSavingSuggestions = useCallback(() => {
+    const suggestions: string[] = []
+
+    if (metrics.isLowPowerMode) {
+      suggestions.push('Reduce animation frame rate')
+      suggestions.push('Implement lazy loading for images and content')
+      suggestions.push('Use CSS transforms instead of JavaScript animations')
+      suggestions.push('Optimize network requests and caching')
+      suggestions.push('Consider using Intersection Observer for scroll-based animations')
+    }
+
+    if (metrics.isCriticalBattery) {
+      suggestions.push('Disable all non-essential animations')
+      suggestions.push('Implement aggressive content virtualization')
+      suggestions.push('Reduce DOM manipulation frequency')
+      suggestions.push('Use passive event listeners')
+    }
+
+    return suggestions
+  }, [metrics])
+
+  // Battery status summary
+  const getBatteryStatus = useCallback(() => {
+    if (metrics.charging) {
+      return `Charging (${Math.round(metrics.level * 100)}%)`
+    }
+
+    if (metrics.isCriticalBattery) {
+      return `Critical (${Math.round(metrics.level * 100)}%)`
+    }
+
+    if (metrics.isLowPowerMode) {
+      return `Low (${Math.round(metrics.level * 100)}%)`
+    }
+
+    return `Good (${Math.round(metrics.level * 100)}%)`
+  }, [metrics])
+
+  return {
+    // Metrics
+    metrics,
+
+    // Controls
+    startMonitoring,
+    stopMonitoring,
+    isMonitoring,
+    enableThrottlingMode,
+    disableThrottlingMode,
+
+    // Status
+    batteryLevel: metrics.level,
+    isCharging: metrics.charging,
+    isLowPowerMode: metrics.isLowPowerMode,
+    isCriticalBattery: metrics.isCriticalBattery,
+    performanceMode: metrics.performanceMode,
+    throttlingEnabled: metrics.throttlingEnabled,
+    throttlingReason: metrics.throttlingReason,
+
+    // Optimization
+    getOptimizationRecommendations,
+    getPowerSavingSuggestions,
+    getBatteryStatus,
+
+    // Raw values
+    level: metrics.level,
+    charging: metrics.charging,
+    chargingTime: metrics.chargingTime,
+    dischargingTime: metrics.dischargingTime,
+
+    // Thresholds
+    thresholds: finalThresholds
+  }
+}