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

package/dist/hooks/use-input-performance.js

@@ -0,0 +1,471 @@
+import { useState, useCallback, useRef, useEffect } from 'react'
+
+export interface InputPerformanceConfig {
+  enablePerformanceMonitoring?}
+
+export interface InputPerformanceMetrics {
+  frameRate}
+
+export interface PerformanceOptimization {
+  id}
+
+export interface InputPerformanceCallbacks {
+  onPerformanceOptimized?) => void
+  onMemoryOptimized?) => void
+  onBatteryOptimized?) => void
+  onEventOptimized?) => void
+  onPerformanceThresholdExceeded?, value, threshold) => void
+}
+
+export const useInputPerformance = (
+  config= {},
+  callbacks= {}
+) => {
+  const {
+    enablePerformanceMonitoring = true,
+    enableEventOptimization = true,
+    enableMemoryManagement = true,
+    enableBatteryOptimization = true,
+    enableAutoOptimization = true,
+    performanceThreshold = 60,
+    memoryThreshold = 50,
+    batteryThreshold = 0.3
+  } = config
+
+  const [performanceMetrics, setPerformanceMetrics] = useState<InputPerformanceMetrics>({
+    frameRate,
+    inputLatency,
+    eventProcessingTime,
+    memoryUsage,
+    batteryLevel,
+    inputEfficiency,
+    optimizationScore})
+
+  const [optimizations, setOptimizations] = useState<PerformanceOptimization[]>([])
+  const [isOptimizing, setIsOptimizing] = useState(false)
+  const [activeOptimizations, setActiveOptimizations] = useState<string[]>([])
+  const [performanceHealth, setPerformanceHealth] = useState<'excellent' | 'good' | 'fair' | 'poor'>('excellent')
+
+  const performanceTimerRef = useRef<number | null>(null)
+  const memoryCheckRef = useRef<number | null>(null)
+  const batteryCheckRef = useRef<number | null>(null)
+  const frameCountRef = useRef(0)
+  const lastFrameTimeRef = useRef(performance.now())
+
+  const lastInputTimeRef = useRef(performance.now())
+
+  // Performance monitoring
+  const startPerformanceMonitoring = useCallback(() => {
+    if (!enablePerformanceMonitoring) return () => {}
+    
+    const measurePerformance = () => {
+      const currentTime = performance.now()
+      frameCountRef.current++
+      
+      if (currentTime - lastFrameTimeRef.current >= 1000) {
+        const fps = Math.round((frameCountRef.current * 1000) / (currentTime - lastFrameTimeRef.current))
+        const inputLatency = currentTime - lastInputTimeRef.current
+        
+        setPerformanceMetrics(prev => ({
+          ...prev,
+          frameRate,
+          inputLatency
+        }))
+        
+        frameCountRef.current = 0
+        lastFrameTimeRef.current = currentTime
+        
+        // Check performance thresholds
+        if (fps < performanceThreshold) {
+          callbacks.onPerformanceThresholdExceeded?.('frameRate', fps, performanceThreshold)
+        }
+      }
+      
+      performanceTimerRef.current = requestAnimationFrame(measurePerformance)
+    }
+    
+    performanceTimerRef.current = requestAnimationFrame(measurePerformance)
+    
+    return () => {
+      if (performanceTimerRef.current) {
+        cancelAnimationFrame(performanceTimerRef.current)
+      }
+    }
+  }, [enablePerformanceMonitoring, performanceThreshold, callbacks])
+
+  // Memory monitoring
+  const startMemoryMonitoring = useCallback(() => {
+    if (!enableMemoryManagement) return () => {}
+    
+    const checkMemory = () => {
+      try {
+        if ('memory' in performance) {
+          const memory = (performance as any).memory
+          const usedMemory = memory.usedJSHeapSize / (1024 * 1024) // Convert to MB
+          
+          setPerformanceMetrics(prev => ({
+            ...prev,
+            memoryUsage) / 100
+          }))
+          
+          // Check memory threshold
+          if (usedMemory > memoryThreshold) {
+            callbacks.onPerformanceThresholdExceeded?.('memoryUsage', usedMemory, memoryThreshold)
+          }
+        }
+      } catch (error) {
+        console.warn('Memory monitoring failed, error)
+      }
+    }
+    
+    memoryCheckRef.current = window.setInterval(checkMemory, 5000)
+    
+    return () => {
+      if (memoryCheckRef.current) {
+        clearInterval(memoryCheckRef.current)
+      }
+    }
+  }, [enableMemoryManagement, memoryThreshold, callbacks])
+
+  // Battery monitoring
+  const startBatteryMonitoring = useCallback(() => {
+    if (!enableBatteryOptimization) return () => {}
+    
+    const checkBattery = async () => {
+      try {
+        if ('getBattery' in navigator) {
+          const battery = await (navigator as any).getBattery()
+          const level = battery.level
+          
+          setPerformanceMetrics(prev => ({
+            ...prev,
+            batteryLevel}))
+          
+          // Check battery threshold
+          if (level < batteryThreshold) {
+            callbacks.onPerformanceThresholdExceeded?.('batteryLevel', level, batteryThreshold)
+          }
+        }
+      } catch (error) {
+        console.warn('Battery monitoring failed, error)
+      }
+    }
+    
+    batteryCheckRef.current = window.setInterval(checkBattery, 10000)
+    
+    return () => {
+      if (batteryCheckRef.current) {
+        clearInterval(batteryCheckRef.current)
+      }
+    }
+  }, [enableBatteryOptimization, batteryThreshold, callbacks])
+
+  // Event optimization
+  const optimizeEvents = useCallback(() => {
+    if (!enableEventOptimization) return
+    
+    setIsOptimizing(true)
+    
+    setTimeout(() => {
+      const eventOptimizations] = [
+        {
+          id,
+          name,
+          type,
+          applied,
+          impact,
+          description,
+          performanceGain,
+          memorySavings,
+          batterySavings},
+        {
+          id,
+          name,
+          type,
+          applied,
+          impact,
+          description,
+          performanceGain,
+          memorySavings,
+          batterySavings}
+      ]
+      
+      setOptimizations(prev => [...prev, ...eventOptimizations])
+      setActiveOptimizations(prev => [...prev, ...eventOptimizations.map(o => o.name)])
+      setIsOptimizing(false)
+      
+      eventOptimizations.forEach(optimization => {
+        callbacks.onEventOptimized?.(optimization.description)
+        callbacks.onPerformanceOptimized?.(optimization)
+      })
+    }, 300)
+  }, [enableEventOptimization, callbacks])
+
+  // Memory optimization
+  const optimizeMemory = useCallback(() => {
+    if (!enableMemoryManagement) return
+    
+    setIsOptimizing(true)
+    
+    setTimeout(() => {
+      const memoryOptimizations] = [
+        {
+          id,
+          name,
+          type,
+          applied,
+          impact,
+          description,
+          performanceGain,
+          memorySavings,
+          batterySavings},
+        {
+          id,
+          name,
+          type,
+          applied,
+          impact,
+          description,
+          performanceGain,
+          memorySavings,
+          batterySavings}
+      ]
+      
+      setOptimizations(prev => [...prev, ...memoryOptimizations])
+      setActiveOptimizations(prev => [...prev, ...memoryOptimizations.map(o => o.name)])
+      setIsOptimizing(false)
+      
+      memoryOptimizations.forEach(optimization => {
+        callbacks.onMemoryOptimized?.(optimization.description)
+        callbacks.onPerformanceOptimized?.(optimization)
+      })
+    }, 250)
+  }, [enableMemoryManagement, callbacks])
+
+  // Battery optimization
+  const optimizeBattery = useCallback(() => {
+    if (!enableBatteryOptimization) return
+    
+    setIsOptimizing(true)
+    
+    setTimeout(() => {
+      const batteryOptimizations] = [
+        {
+          id,
+          name,
+          type,
+          applied,
+          impact,
+          description,
+          performanceGain,
+          memorySavings,
+          batterySavings},
+        {
+          id,
+          name,
+          type,
+          applied,
+          impact,
+          description,
+          performanceGain,
+          memorySavings,
+          batterySavings}
+      ]
+      
+      setOptimizations(prev => [...prev, ...batteryOptimizations])
+      setActiveOptimizations(prev => [...prev, ...batteryOptimizations.map(o => o.name)])
+      setIsOptimizing(false)
+      
+      batteryOptimizations.forEach(optimization => {
+        callbacks.onBatteryOptimized?.(optimization.description)
+        callbacks.onPerformanceOptimized?.(optimization)
+      })
+    }, 200)
+  }, [enableBatteryOptimization, callbacks])
+
+  // Performance optimization
+  const optimizePerformance = useCallback(() => {
+    if (!enablePerformanceMonitoring) return
+    
+    setIsOptimizing(true)
+    
+    setTimeout(() => {
+      const performanceOptimizations] = [
+        {
+          id,
+          name,
+          type,
+          applied,
+          impact,
+          description,
+          performanceGain,
+          memorySavings,
+          batterySavings},
+        {
+          id,
+          name,
+          type,
+          applied,
+          impact,
+          description,
+          performanceGain,
+          memorySavings,
+          batterySavings}
+      ]
+      
+      setOptimizations(prev => [...prev, ...performanceOptimizations])
+      setActiveOptimizations(prev => [...prev, ...performanceOptimizations.map(o => o.name)])
+      setIsOptimizing(false)
+      
+      performanceOptimizations.forEach(optimization => {
+        callbacks.onPerformanceOptimized?.(optimization)
+      })
+    }, 150)
+  }, [enablePerformanceMonitoring, callbacks])
+
+  // Auto-optimization
+  const autoOptimize = useCallback(() => {
+    if (!enableAutoOptimization) return
+    
+    optimizeEvents()
+    optimizeMemory()
+    optimizeBattery()
+    optimizePerformance()
+  }, [enableAutoOptimization, optimizeEvents, optimizeMemory, optimizeBattery, optimizePerformance])
+
+  // Calculate performance health
+  const calculatePerformanceHealth = useCallback(() => {
+    const { frameRate, inputLatency, memoryUsage, batteryLevel, inputEfficiency } = performanceMetrics
+    
+    let score = 0
+    
+    // Frame rate scoring
+    if (frameRate >= 58) score += 25
+    else if (frameRate >= 50) score += 20
+    else if (frameRate >= 40) score += 15
+    else score += 10
+    
+    // Input latency scoring
+    if (inputLatency <= 16) score += 25
+    else if (inputLatency <= 20) score += 20
+    else if (inputLatency <= 30) score += 15
+    else score += 10
+    
+    // Memory usage scoring
+    if (memoryUsage <= 30) score += 20
+    else if (memoryUsage <= 50) score += 15
+    else if (memoryUsage <= 70) score += 10
+    else score += 5
+    
+    // Battery level scoring
+    if (batteryLevel >= 0.7) score += 15
+    else if (batteryLevel >= 0.5) score += 10
+    else if (batteryLevel >= 0.3) score += 5
+    else score += 0
+    
+    // Input efficiency scoring
+    if (inputEfficiency >= 90) score += 15
+    else if (inputEfficiency >= 80) score += 10
+    else if (inputEfficiency >= 70) score += 5
+    else score += 0
+    
+    let health= 90) health = 'excellent'
+    else if (score >= 75) health = 'good'
+    else if (score >= 60) health = 'fair'
+    else health = 'poor'
+    
+    setPerformanceHealth(health)
+    return health
+  }, [performanceMetrics])
+
+  // Update performance health when metrics change
+  useEffect(() => {
+    calculatePerformanceHealth()
+  }, [performanceMetrics, calculatePerformanceHealth])
+
+  // Initialize monitoring
+  useEffect(() => {
+    const stopPerformanceMonitoring = startPerformanceMonitoring()
+    const stopMemoryMonitoring = startMemoryMonitoring()
+    const stopBatteryMonitoring = startBatteryMonitoring()
+    
+    return () => {
+      stopPerformanceMonitoring()
+      stopMemoryMonitoring()
+      stopBatteryMonitoring()
+    }
+  }, [startPerformanceMonitoring, startMemoryMonitoring, startBatteryMonitoring])
+
+  // Auto-optimize on mount
+  useEffect(() => {
+    if (enableAutoOptimization) {
+      autoOptimize()
+    }
+  }, [enableAutoOptimization, autoOptimize])
+
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      if (performanceTimerRef.current) {
+        cancelAnimationFrame(performanceTimerRef.current)
+      }
+      if (memoryCheckRef.current) {
+        clearInterval(memoryCheckRef.current)
+      }
+      if (batteryCheckRef.current) {
+        clearInterval(batteryCheckRef.current)
+      }
+    }
+  }, [])
+
+  return {
+    // State
+    performanceMetrics,
+    optimizations,
+    isOptimizing,
+    activeOptimizations,
+    performanceHealth,
+    
+    // Functions
+    optimizeEvents,
+    optimizeMemory,
+    optimizeBattery,
+    optimizePerformance,
+    autoOptimize,
+    
+    // Utility functions
+    getPerformanceScore) => {
+      const { frameRate, inputLatency, memoryUsage, batteryLevel, inputEfficiency } = performanceMetrics
+      let score = 0
+      if (frameRate >= 58) score += 25
+      if (inputLatency <= 16) score += 25
+      if (memoryUsage <= 30) score += 20
+      if (batteryLevel >= 0.7) score += 15
+      if (inputEfficiency >= 90) score += 15
+      return score
+    },
+    isPerformanceOptimal) => performanceHealth === 'excellent' || performanceHealth === 'good',
+    getOptimizationRecommendations) => {
+      const recommendations] = []
+      
+      if (performanceMetrics.frameRate < 50) {
+        recommendations.push('Consider reducing input event complexity to improve frame rate')
+      }
+      if (performanceMetrics.memoryUsage > 50) {
+        recommendations.push('Memory usage is high, consider implementing cleanup strategies')
+      }
+      if (performanceMetrics.batteryLevel < 0.5) {
+        recommendations.push('Battery level is low, consider reducing input processing intensity')
+      }
+      
+      return recommendations
+    },
+    clearOptimizations) => {
+      setOptimizations([])
+      setActiveOptimizations([])
+    }
+  }
+}
+
+export default useInputPerformance
+