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

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

@@ -1,26 +1,48 @@
 import { useState, useCallback, useRef, useEffect } from 'react'
 
 export interface BatteryConsciousLoadingConfig {
-  enableBatteryMonitoring?}
+  enableBatteryMonitoring?: boolean
+  enableLoadingOptimization?: boolean
+  enablePerformanceAdjustment?: boolean
+  enableUserNotification?: boolean
+  enableAutoOptimization?: boolean
+  batteryThresholds?: {
+    critical: number
+    low: number
+    medium: number
+    high: number
+  }
 
 }
 
 export interface BatteryState {
-  level}
+  level: number
+  charging: boolean
+  chargingTime: number
+  dischargingTime: number
+  status: 'critical' | 'low' | 'medium' | 'high' | 'full'
+}
 
 export interface LoadingOptimization {
-  id}
+  id: string
+  name: string
+  type: 'battery' | 'performance' | 'animation' | 'memory'
+  applied: boolean
+  impact: 'low' | 'medium' | 'high'
+  description: string
+  batterySavings: number
+}
 
 export interface BatteryConsciousLoadingCallbacks {
-  onBatteryLevelChanged?) => void
-  onLoadingOptimized?) => void
-  onPerformanceAdjusted?) => void
-  onUserNotified?) => void
+  onBatteryLevelChanged?: (batteryState: BatteryState) => void
+  onLoadingOptimized?: (optimization: LoadingOptimization) => void
+  onPerformanceAdjusted?: (adjustment: string) => void
+  onUserNotified?: (notification: string) => void
 }
 
 export const useBatteryConsciousLoading = (
-  config= {},
-  callbacks= {}
+  config: BatteryConsciousLoadingConfig = {},
+  callbacks: BatteryConsciousLoadingCallbacks = {}
 ) => {
   const {
     enableBatteryMonitoring = true,
@@ -29,19 +51,21 @@ export const useBatteryConsciousLoading = (
     enableUserNotification = true,
     enableAutoOptimization = true,
     batteryThresholds = {
-      critical,
-      low,
-      medium,
-      high},
+      critical: 0.1,
+      low: 0.3,
+      medium: 0.7,
+      high: 0.9
+    },
 
   } = config
 
   const [batteryState, setBatteryState] = useState<BatteryState>({
-    level,
-    charging,
-    chargingTime,
-    dischargingTime,
-    status})
+    level: 1,
+    charging: false,
+    chargingTime: 0,
+    dischargingTime: 0,
+    status: 'full'
+  })
 
   const [loadingOptimizations, setLoadingOptimizations] = useState<LoadingOptimization[]>([])
   const [isOptimizing, setIsOptimizing] = useState(false)
@@ -66,13 +90,14 @@ export const useBatteryConsciousLoading = (
           const chargingTime = battery.chargingTime || 0
           const dischargingTime = battery.dischargingTime || 0
           
-          let status= batteryThresholds.critical) status = 'critical'
+          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= {
+          const newBatteryState: BatteryState = {
             level,
             charging,
             chargingTime,
@@ -89,7 +114,7 @@ export const useBatteryConsciousLoading = (
           }
         }
       } catch (error) {
-        console.warn('Battery monitoring failed, error)
+        console.warn('Battery monitoring failed:', error)
       }
     }
     
@@ -107,84 +132,96 @@ export const useBatteryConsciousLoading = (
   }, [enableBatteryMonitoring, batteryThresholds, enableAutoOptimization, callbacks])
 
   // Auto-optimize for battery level
-  const autoOptimizeForBattery = useCallback((batteryState) => {
+  const autoOptimizeForBattery = useCallback((batteryState: BatteryState) => {
     if (!enableLoadingOptimization) return
 
     setIsOptimizing(true)
     
     setTimeout(() => {
-      let newPerformanceMode] = []
+      let newPerformanceMode: 'minimal' | 'balanced' | 'full'
+      let optimizations: LoadingOptimization[] = []
       let savings = 0
       
       switch (batteryState.status) {
-        case 'critical'= 'minimal'
+        case 'critical':
+          newPerformanceMode = 'minimal'
           optimizations = [
             {
-              id,
-              name,
-              type,
-              applied,
-              impact,
-              description,
-              batterySavings},
+              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,
-              name,
-              type,
-              applied,
-              impact,
-              description,
-              batterySavings}
+              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'= 'minimal'
+        case 'low':
+          newPerformanceMode = 'minimal'
           optimizations = [
             {
-              id,
-              name,
-              type,
-              applied,
-              impact,
-              description,
-              batterySavings},
+              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,
-              name,
-              type,
-              applied,
-              impact,
-              description,
-              batterySavings}
+              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'= 'balanced'
+        case 'medium':
+          newPerformanceMode = 'balanced'
           optimizations = [
             {
-              id,
-              name,
-              type,
-              applied,
-              impact,
-              description,
-              batterySavings}
+              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'= 'full'
+        case 'high':
+        case 'full':
+          newPerformanceMode = 'full'
           optimizations = [
             {
-              id,
-              name,
-              type,
-              applied,
-              impact,
-              description,
-              batterySavings}
+              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
@@ -197,7 +234,7 @@ export const useBatteryConsciousLoading = (
       
       // Notify user if enabled
       if (enableUserNotification) {
-        const notification = `Battery optimization applied} mode with ${savings}% battery savings`
+        const notification = `Battery optimization applied: ${newPerformanceMode} mode with ${savings}% battery savings`
         setNotifications(prev => [...prev, notification])
         callbacks.onUserNotified?.(notification)
       }
@@ -223,23 +260,25 @@ export const useBatteryConsciousLoading = (
     setIsOptimizing(true)
     
     setTimeout(() => {
-      const manualOptimizations] = [
+      const manualOptimizations: LoadingOptimization[] = [
         {
-          id,
-          name,
-          type,
-          applied,
-          impact,
-          description,
-          batterySavings},
+          id: 'manual-battery-1',
+          name: 'Manual Battery Optimization',
+          type: 'battery',
+          applied: true,
+          impact: 'medium',
+          description: 'Manually applied battery-conscious loading optimization',
+          batterySavings: 20
+        },
         {
-          id,
-          name,
-          type,
-          applied,
-          impact,
-          description,
-          batterySavings}
+          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])
@@ -266,23 +305,25 @@ export const useBatteryConsciousLoading = (
     setIsOptimizing(true)
     
     setTimeout(() => {
-      const memoryOptimizations] = [
+      const memoryOptimizations: LoadingOptimization[] = [
         {
-          id,
-          name,
-          type,
-          applied,
-          impact,
-          description,
-          batterySavings},
+          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,
-          name,
-          type,
-          applied,
-          impact,
-          description,
-          batterySavings}
+          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])
@@ -309,23 +350,25 @@ export const useBatteryConsciousLoading = (
     setIsOptimizing(true)
     
     setTimeout(() => {
-      const animationOptimizations] = [
+      const animationOptimizations: LoadingOptimization[] = [
         {
-          id,
-          name,
-          type,
-          applied,
-          impact,
-          description,
-          batterySavings},
+          id: 'animation-battery-1',
+          name: 'Battery-Conscious Animations',
+          type: 'animation',
+          applied: true,
+          impact: 'high',
+          description: 'Animations optimized for minimal battery impact',
+          batterySavings: 25
+        },
         {
-          id,
-          name,
-          type,
-          applied,
-          impact,
-          description,
-          batterySavings}
+          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])
@@ -347,7 +390,7 @@ export const useBatteryConsciousLoading = (
 
   // Get battery-aware loading recommendations
   const getBatteryLoadingRecommendations = useCallback(() => {
-    const recommendations] = []
+    const recommendations: string[] = []
     
     if (batteryState.status === 'critical') {
       recommendations.push('Use minimal loading animations to preserve battery')
@@ -417,13 +460,13 @@ export const useBatteryConsciousLoading = (
     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,
+    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
   }