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

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

@@ -1,299 +1,219 @@
-import { useState, useEffect, useCallback, useRef, useMemo } from 'react'
-
-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 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()
+import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
+const DEFAULT_THRESHOLDS = {
+    low: 0.3,
+    critical: 0.15,
+    warning: 0.5
+};
+export const useBatteryStatus = (options = {}) => {
+    const { updateInterval = 5000, thresholds = {}, enableThrottling = true, callbacks = {} } = options;
+    const [metrics, setMetrics] = useState({
+        level: 1,
+        charging: true,
+        chargingTime: 0,
+        dischargingTime: 0,
+        isLowPowerMode: false,
+        isCriticalBattery: false,
+        performanceMode: 'high',
+        throttlingEnabled: false
+    });
+    const [isMonitoring, setIsMonitoring] = useState(false);
+    const intervalIdRef = useRef();
+    const batteryRef = useRef(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, charging) => {
+        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, charging) => {
+        if (!enableThrottling)
+            return { should: false };
+        if (level <= finalThresholds.critical) {
+            return { should: true, reason: 'Critical battery level' };
         }
-        
-        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
+        if (level <= finalThresholds.low && !charging) {
+            return { should: true, reason: 'Low battery level' };
         }
-
-        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)
+        return { should: false };
+    }, [enableThrottling, finalThresholds]);
+    // Update battery information
+    const updateBatteryInfo = useCallback(async () => {
+        if ('getBattery' in navigator) {
+            try {
+                if (!batteryRef.current) {
+                    batteryRef.current = await navigator.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 = {
+                    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);
+            }
         }
-
-        if (charging !== metrics.charging && callbacks.onChargingStateChange) {
-          callbacks.onChargingStateChange(charging)
+    }, [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);
         }
-
-        if (performanceMode !== metrics.performanceMode && callbacks.onPerformanceModeChange) {
-          callbacks.onPerformanceModeChange(performanceMode)
+    }, []);
+    // Manual throttling controls
+    const enableThrottlingMode = useCallback((reason) => {
+        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 = [];
+        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');
         }
-
-        if (shouldThrottleNow !== metrics.throttlingEnabled && callbacks.onThrottlingChange) {
-          callbacks.onThrottlingChange(shouldThrottleNow, reason)
+        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');
         }
-
-      } 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
-  }
-}
+        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 = [];
+        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
+    };
+};