@rakeyshgidwani/roger-ui-bank-theme-jeremy 0.5.3

package/dist/hooks/use-advanced-transition-system.d.ts

@@ -0,0 +1,59 @@
+export interface TransitionConfig {
+    duration?: number;
+    easing?: 'ease-out' | 'ease-in' | 'ease-in-out' | 'ease-out-quint' | 'ease-in-quint' | 'ease-in-out-quint' | 'ease-out-expo' | 'ease-in-expo' | 'ease-in-out-expo' | 'ease-out-circ' | 'ease-in-circ' | 'ease-in-out-circ';
+    delay?: number;
+    performance?: boolean;
+    deviceOptimization?: boolean;
+    accessibility?: boolean;
+    batteryAware?: boolean;
+}
+export interface TransitionState {
+    isTransitioning: boolean;
+    currentEasing: string;
+    currentDuration: number;
+    currentDelay: number;
+    performanceScore: number;
+    deviceType: 'mobile' | 'tablet' | 'desktop';
+    batteryLevel: 'normal' | 'low' | 'critical';
+    reducedMotion: boolean;
+}
+export interface TransitionPerformanceMetrics {
+    frameRate: number;
+    memoryUsage: number;
+    transitionTime: number;
+    smoothness: number;
+    batteryImpact: number;
+}
+export interface AdvancedTransitionSystemCallbacks {
+    onTransitionStart?: (config: TransitionConfig) => void;
+    onTransitionComplete?: (duration: number) => void;
+    onPerformanceOptimized?: (metrics: TransitionPerformanceMetrics) => void;
+    onDeviceOptimized?: (deviceType: string) => void;
+    onAccessibilityEnhanced?: (feature: string) => void;
+}
+export declare const useAdvancedTransitionSystem: (config?: TransitionConfig, callbacks?: AdvancedTransitionSystemCallbacks) => {
+    transitionState: TransitionState;
+    performanceMetrics: TransitionPerformanceMetrics;
+    isOptimizing: boolean;
+    optimizations: string[];
+    startTransition: (customConfig?: Partial<TransitionConfig>) => void;
+    optimizeForDevice: () => void;
+    enhanceAccessibility: () => void;
+    startPerformanceMonitoring: () => () => void;
+    autoOptimize: () => void;
+    getTransitionDuration: () => number;
+    getTransitionEasing: () => string;
+    getTransitionDelay: () => number;
+    isTransitionActive: () => boolean;
+    getDeviceType: () => "mobile" | "tablet" | "desktop";
+    getBatteryLevel: () => "normal" | "low" | "critical";
+    getReducedMotion: () => boolean;
+    getPerformanceScore: () => number;
+    isPerformanceOptimal: () => boolean;
+    getFrameRate: () => number;
+    getSmoothness: () => number;
+    getBatteryImpact: () => number;
+    clearOptimizations: () => void;
+};
+export default useAdvancedTransitionSystem;
+//# sourceMappingURL=use-advanced-transition-system.d.ts.map

package/dist/hooks/use-advanced-transition-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-advanced-transition-system.d.ts","sourceRoot":"","sources":["../../src/hooks/use-advanced-transition-system.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,aAAa,GAAG,gBAAgB,GAAG,eAAe,GAAG,mBAAmB,GAAG,eAAe,GAAG,cAAc,GAAG,kBAAkB,GAAG,eAAe,GAAG,cAAc,GAAG,kBAAkB,CAAA;IAC1N,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,eAAe,EAAE,OAAO,CAAA;IACxB,aAAa,EAAE,MAAM,CAAA;IACrB,eAAe,EAAE,MAAM,CAAA;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAA;IAC3C,YAAY,EAAE,QAAQ,GAAG,KAAK,GAAG,UAAU,CAAA;IAC3C,aAAa,EAAE,OAAO,CAAA;CACvB;AAED,MAAM,WAAW,4BAA4B;IAC3C,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,iCAAiC;IAChD,iBAAiB,CAAC,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,CAAA;IACtD,oBAAoB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IACjD,sBAAsB,CAAC,EAAE,CAAC,OAAO,EAAE,4BAA4B,KAAK,IAAI,CAAA;IACxE,iBAAiB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAA;IAChD,uBAAuB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CACpD;AAED,eAAO,MAAM,2BAA2B,GACtC,SAAQ,gBAAqB,EAC7B,YAAW,iCAAsC;;;;;qCAmIG,OAAO,CAAC,gBAAgB,CAAC;;;;;;;;;;;;;;;;;;CA0N9E,CAAA;AAED,eAAe,2BAA2B,CAAA"}

package/dist/hooks/use-advanced-transition-system.esm.js

@@ -0,0 +1,287 @@
+import { useState, useCallback, useRef, useEffect } from 'react';
+export const useAdvancedTransitionSystem = (config = {}, callbacks = {}) => {
+    const { duration = 300, easing = 'ease-out', delay = 0, performance: enablePerformance = true, deviceOptimization = true, accessibility = true, batteryAware = true } = config;
+    const [transitionState, setTransitionState] = useState({
+        isTransitioning: false,
+        currentEasing: easing,
+        currentDuration: duration,
+        currentDelay: delay,
+        performanceScore: 0,
+        deviceType: 'desktop',
+        batteryLevel: 'normal',
+        reducedMotion: false
+    });
+    const [performanceMetrics, setPerformanceMetrics] = useState({
+        frameRate: 60,
+        memoryUsage: 0,
+        transitionTime: 0,
+        smoothness: 0,
+        batteryImpact: 0
+    });
+    const [isOptimizing, setIsOptimizing] = useState(false);
+    const [optimizations, setOptimizations] = useState([]);
+    const transitionStartTimeRef = useRef(0);
+    const frameCountRef = useRef(0);
+    const lastFrameTimeRef = useRef(0);
+    const performanceTimerRef = useRef(null);
+    // Detect device type and optimize transitions accordingly
+    const detectDeviceType = useCallback(() => {
+        const width = window.innerWidth;
+        let deviceType = 'desktop';
+        if (width <= 480) {
+            deviceType = 'mobile';
+        }
+        else if (width <= 768) {
+            deviceType = 'tablet';
+        }
+        else {
+            deviceType = 'desktop';
+        }
+        setTransitionState(prev => ({
+            ...prev,
+            deviceType
+        }));
+        return deviceType;
+    }, []);
+    // Detect reduced motion preference
+    const detectReducedMotion = useCallback(() => {
+        const prefersReducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+        setTransitionState(prev => ({
+            ...prev,
+            reducedMotion: prefersReducedMotion
+        }));
+        return prefersReducedMotion;
+    }, []);
+    // Simulate battery level detection (in real app, use Battery API)
+    const detectBatteryLevel = useCallback(() => {
+        // Simulate battery levels for demo purposes
+        const batteryLevels = ['normal', 'low', 'critical'];
+        const randomLevel = batteryLevels[Math.floor(Math.random() * batteryLevels.length)];
+        setTransitionState(prev => ({
+            ...prev,
+            batteryLevel: randomLevel
+        }));
+        return randomLevel;
+    }, []);
+    // Optimize transition duration based on device and battery
+    const optimizeTransitionDuration = useCallback((baseDuration) => {
+        let optimizedDuration = baseDuration;
+        // Device-specific optimization
+        if (deviceOptimization) {
+            switch (transitionState.deviceType) {
+                case 'mobile':
+                    optimizedDuration = Math.min(baseDuration, 200);
+                    break;
+                case 'tablet':
+                    optimizedDuration = Math.min(baseDuration, 300);
+                    break;
+                case 'desktop':
+                    optimizedDuration = baseDuration;
+                    break;
+            }
+        }
+        // Battery-aware optimization
+        if (batteryAware) {
+            switch (transitionState.batteryLevel) {
+                case 'low':
+                    optimizedDuration = Math.min(optimizedDuration, 150);
+                    break;
+                case 'critical':
+                    optimizedDuration = Math.min(optimizedDuration, 100);
+                    break;
+                case 'normal':
+                default:
+                    break;
+            }
+        }
+        // Reduced motion optimization
+        if (transitionState.reducedMotion) {
+            optimizedDuration = 0;
+        }
+        return optimizedDuration;
+    }, [deviceOptimization, batteryAware, transitionState.deviceType, transitionState.batteryLevel, transitionState.reducedMotion]);
+    // Start a transition with optimization
+    const startTransition = useCallback((customConfig) => {
+        const finalConfig = { ...config, ...customConfig };
+        const optimizedDuration = optimizeTransitionDuration(finalConfig.duration || duration);
+        setTransitionState(prev => ({
+            ...prev,
+            isTransitioning: true,
+            currentDuration: optimizedDuration,
+            currentDelay: finalConfig.delay || delay,
+            currentEasing: finalConfig.easing || easing
+        }));
+        transitionStartTimeRef.current = performance.now();
+        frameCountRef.current = 0;
+        lastFrameTimeRef.current = performance.now();
+        callbacks.onTransitionStart?.(finalConfig);
+        // Complete transition after duration
+        setTimeout(() => {
+            setTransitionState(prev => ({
+                ...prev,
+                isTransitioning: false
+            }));
+            const actualDuration = performance.now() - transitionStartTimeRef.current;
+            callbacks.onTransitionComplete?.(actualDuration);
+        }, optimizedDuration + (finalConfig.delay || delay));
+    }, [config, duration, delay, easing, optimizeTransitionDuration, callbacks]);
+    // Performance monitoring
+    const startPerformanceMonitoring = useCallback(() => {
+        if (!enablePerformance)
+            return () => { };
+        const measurePerformance = () => {
+            const currentTime = performance.now();
+            const deltaTime = currentTime - lastFrameTimeRef.current;
+            if (deltaTime > 0) {
+                frameCountRef.current++;
+                const currentFrameRate = 1000 / deltaTime;
+                // Calculate smoothness based on frame rate consistency
+                const smoothness = Math.max(0, 100 - Math.abs(currentFrameRate - 60));
+                // Simulate memory usage (in real app, use Performance API)
+                const memoryUsage = Math.random() * 100;
+                // Calculate transition time if transitioning
+                const transitionTime = transitionState.isTransitioning
+                    ? currentTime - transitionStartTimeRef.current
+                    : 0;
+                // Calculate battery impact based on performance
+                const batteryImpact = Math.max(0, 100 - (currentFrameRate * 0.5) - memoryUsage * 0.3);
+                setPerformanceMetrics({
+                    frameRate: Math.round(currentFrameRate),
+                    memoryUsage: Math.round(memoryUsage),
+                    transitionTime: Math.round(transitionTime),
+                    smoothness: Math.round(smoothness),
+                    batteryImpact: Math.round(batteryImpact)
+                });
+                // Update performance score
+                const overallScore = Math.round((smoothness + batteryImpact) / 2);
+                setTransitionState(prev => ({
+                    ...prev,
+                    performanceScore: overallScore
+                }));
+                lastFrameTimeRef.current = currentTime;
+                callbacks.onPerformanceOptimized?.({
+                    frameRate: Math.round(currentFrameRate),
+                    memoryUsage: Math.round(memoryUsage),
+                    transitionTime: Math.round(transitionTime),
+                    smoothness: Math.round(smoothness),
+                    batteryImpact: Math.round(batteryImpact)
+                });
+            }
+            performanceTimerRef.current = requestAnimationFrame(measurePerformance);
+        };
+        performanceTimerRef.current = requestAnimationFrame(measurePerformance);
+        return () => {
+            if (performanceTimerRef.current) {
+                cancelAnimationFrame(performanceTimerRef.current);
+            }
+        };
+    }, [performance, transitionState.isTransitioning, callbacks]);
+    // Device optimization
+    const optimizeForDevice = useCallback(() => {
+        if (!deviceOptimization)
+            return;
+        const deviceType = detectDeviceType();
+        const optimizations = [];
+        switch (deviceType) {
+            case 'mobile':
+                optimizations.push('Mobile-optimized transitions (200ms max)');
+                optimizations.push('Reduced animation complexity');
+                optimizations.push('Touch-friendly timing');
+                break;
+            case 'tablet':
+                optimizations.push('Tablet-optimized transitions (300ms max)');
+                optimizations.push('Balanced performance and smoothness');
+                break;
+            case 'desktop':
+                optimizations.push('Desktop-optimized transitions (full duration)');
+                optimizations.push('Maximum visual quality');
+                break;
+        }
+        setOptimizations(prev => [...prev, ...optimizations]);
+        callbacks.onDeviceOptimized?.(deviceType);
+    }, [deviceOptimization, detectDeviceType, callbacks]);
+    // Accessibility enhancement
+    const enhanceAccessibility = useCallback(() => {
+        if (!accessibility)
+            return;
+        const enhancements = [
+            'Reduced motion support',
+            'Screen reader compatibility',
+            'Focus management during transitions',
+            'ARIA transition states',
+            'Keyboard navigation support'
+        ];
+        enhancements.forEach(enhancement => {
+            callbacks.onAccessibilityEnhanced?.(enhancement);
+        });
+    }, [accessibility, callbacks]);
+    // Auto-optimize on mount
+    const autoOptimize = useCallback(() => {
+        setIsOptimizing(true);
+        setTimeout(() => {
+            detectDeviceType();
+            detectReducedMotion();
+            detectBatteryLevel();
+            optimizeForDevice();
+            enhanceAccessibility();
+            setIsOptimizing(false);
+        }, 200);
+    }, [detectDeviceType, detectReducedMotion, detectBatteryLevel, optimizeForDevice, enhanceAccessibility]);
+    // Initialize on mount
+    useEffect(() => {
+        autoOptimize();
+        const stopPerformanceMonitoring = startPerformanceMonitoring();
+        // Listen for device changes
+        const handleResize = () => {
+            detectDeviceType();
+        };
+        // Listen for reduced motion changes
+        const mediaQuery = window.matchMedia('(prefers-reduced-motion: reduce)');
+        const handleMotionChange = () => {
+            detectReducedMotion();
+        };
+        window.addEventListener('resize', handleResize);
+        mediaQuery.addEventListener('change', handleMotionChange);
+        return () => {
+            stopPerformanceMonitoring();
+            window.removeEventListener('resize', handleResize);
+            mediaQuery.removeEventListener('change', handleMotionChange);
+        };
+    }, [autoOptimize, startPerformanceMonitoring, detectDeviceType, detectReducedMotion]);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            if (performanceTimerRef.current) {
+                cancelAnimationFrame(performanceTimerRef.current);
+            }
+        };
+    }, []);
+    return {
+        // State
+        transitionState,
+        performanceMetrics,
+        isOptimizing,
+        optimizations,
+        // Functions
+        startTransition,
+        optimizeForDevice,
+        enhanceAccessibility,
+        startPerformanceMonitoring,
+        autoOptimize,
+        // Utility functions
+        getTransitionDuration: () => transitionState.currentDuration,
+        getTransitionEasing: () => transitionState.currentEasing,
+        getTransitionDelay: () => transitionState.currentDelay,
+        isTransitionActive: () => transitionState.isTransitioning,
+        getDeviceType: () => transitionState.deviceType,
+        getBatteryLevel: () => transitionState.batteryLevel,
+        getReducedMotion: () => transitionState.reducedMotion,
+        getPerformanceScore: () => transitionState.performanceScore,
+        isPerformanceOptimal: () => transitionState.performanceScore >= 80,
+        getFrameRate: () => performanceMetrics.frameRate,
+        getSmoothness: () => performanceMetrics.smoothness,
+        getBatteryImpact: () => performanceMetrics.batteryImpact,
+        clearOptimizations: () => setOptimizations([])
+    };
+};
+export default useAdvancedTransitionSystem;

package/dist/hooks/use-advanced-transition-system.js

@@ -0,0 +1,287 @@
+import { useState, useCallback, useRef, useEffect } from 'react';
+export const useAdvancedTransitionSystem = (config = {}, callbacks = {}) => {
+    const { duration = 300, easing = 'ease-out', delay = 0, performance: enablePerformance = true, deviceOptimization = true, accessibility = true, batteryAware = true } = config;
+    const [transitionState, setTransitionState] = useState({
+        isTransitioning: false,
+        currentEasing: easing,
+        currentDuration: duration,
+        currentDelay: delay,
+        performanceScore: 0,
+        deviceType: 'desktop',
+        batteryLevel: 'normal',
+        reducedMotion: false
+    });
+    const [performanceMetrics, setPerformanceMetrics] = useState({
+        frameRate: 60,
+        memoryUsage: 0,
+        transitionTime: 0,
+        smoothness: 0,
+        batteryImpact: 0
+    });
+    const [isOptimizing, setIsOptimizing] = useState(false);
+    const [optimizations, setOptimizations] = useState([]);
+    const transitionStartTimeRef = useRef(0);
+    const frameCountRef = useRef(0);
+    const lastFrameTimeRef = useRef(0);
+    const performanceTimerRef = useRef(null);
+    // Detect device type and optimize transitions accordingly
+    const detectDeviceType = useCallback(() => {
+        const width = window.innerWidth;
+        let deviceType = 'desktop';
+        if (width <= 480) {
+            deviceType = 'mobile';
+        }
+        else if (width <= 768) {
+            deviceType = 'tablet';
+        }
+        else {
+            deviceType = 'desktop';
+        }
+        setTransitionState(prev => ({
+            ...prev,
+            deviceType
+        }));
+        return deviceType;
+    }, []);
+    // Detect reduced motion preference
+    const detectReducedMotion = useCallback(() => {
+        const prefersReducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+        setTransitionState(prev => ({
+            ...prev,
+            reducedMotion: prefersReducedMotion
+        }));
+        return prefersReducedMotion;
+    }, []);
+    // Simulate battery level detection (in real app, use Battery API)
+    const detectBatteryLevel = useCallback(() => {
+        // Simulate battery levels for demo purposes
+        const batteryLevels = ['normal', 'low', 'critical'];
+        const randomLevel = batteryLevels[Math.floor(Math.random() * batteryLevels.length)];
+        setTransitionState(prev => ({
+            ...prev,
+            batteryLevel: randomLevel
+        }));
+        return randomLevel;
+    }, []);
+    // Optimize transition duration based on device and battery
+    const optimizeTransitionDuration = useCallback((baseDuration) => {
+        let optimizedDuration = baseDuration;
+        // Device-specific optimization
+        if (deviceOptimization) {
+            switch (transitionState.deviceType) {
+                case 'mobile':
+                    optimizedDuration = Math.min(baseDuration, 200);
+                    break;
+                case 'tablet':
+                    optimizedDuration = Math.min(baseDuration, 300);
+                    break;
+                case 'desktop':
+                    optimizedDuration = baseDuration;
+                    break;
+            }
+        }
+        // Battery-aware optimization
+        if (batteryAware) {
+            switch (transitionState.batteryLevel) {
+                case 'low':
+                    optimizedDuration = Math.min(optimizedDuration, 150);
+                    break;
+                case 'critical':
+                    optimizedDuration = Math.min(optimizedDuration, 100);
+                    break;
+                case 'normal':
+                default:
+                    break;
+            }
+        }
+        // Reduced motion optimization
+        if (transitionState.reducedMotion) {
+            optimizedDuration = 0;
+        }
+        return optimizedDuration;
+    }, [deviceOptimization, batteryAware, transitionState.deviceType, transitionState.batteryLevel, transitionState.reducedMotion]);
+    // Start a transition with optimization
+    const startTransition = useCallback((customConfig) => {
+        const finalConfig = { ...config, ...customConfig };
+        const optimizedDuration = optimizeTransitionDuration(finalConfig.duration || duration);
+        setTransitionState(prev => ({
+            ...prev,
+            isTransitioning: true,
+            currentDuration: optimizedDuration,
+            currentDelay: finalConfig.delay || delay,
+            currentEasing: finalConfig.easing || easing
+        }));
+        transitionStartTimeRef.current = performance.now();
+        frameCountRef.current = 0;
+        lastFrameTimeRef.current = performance.now();
+        callbacks.onTransitionStart?.(finalConfig);
+        // Complete transition after duration
+        setTimeout(() => {
+            setTransitionState(prev => ({
+                ...prev,
+                isTransitioning: false
+            }));
+            const actualDuration = performance.now() - transitionStartTimeRef.current;
+            callbacks.onTransitionComplete?.(actualDuration);
+        }, optimizedDuration + (finalConfig.delay || delay));
+    }, [config, duration, delay, easing, optimizeTransitionDuration, callbacks]);
+    // Performance monitoring
+    const startPerformanceMonitoring = useCallback(() => {
+        if (!enablePerformance)
+            return () => { };
+        const measurePerformance = () => {
+            const currentTime = performance.now();
+            const deltaTime = currentTime - lastFrameTimeRef.current;
+            if (deltaTime > 0) {
+                frameCountRef.current++;
+                const currentFrameRate = 1000 / deltaTime;
+                // Calculate smoothness based on frame rate consistency
+                const smoothness = Math.max(0, 100 - Math.abs(currentFrameRate - 60));
+                // Simulate memory usage (in real app, use Performance API)
+                const memoryUsage = Math.random() * 100;
+                // Calculate transition time if transitioning
+                const transitionTime = transitionState.isTransitioning
+                    ? currentTime - transitionStartTimeRef.current
+                    : 0;
+                // Calculate battery impact based on performance
+                const batteryImpact = Math.max(0, 100 - (currentFrameRate * 0.5) - memoryUsage * 0.3);
+                setPerformanceMetrics({
+                    frameRate: Math.round(currentFrameRate),
+                    memoryUsage: Math.round(memoryUsage),
+                    transitionTime: Math.round(transitionTime),
+                    smoothness: Math.round(smoothness),
+                    batteryImpact: Math.round(batteryImpact)
+                });
+                // Update performance score
+                const overallScore = Math.round((smoothness + batteryImpact) / 2);
+                setTransitionState(prev => ({
+                    ...prev,
+                    performanceScore: overallScore
+                }));
+                lastFrameTimeRef.current = currentTime;
+                callbacks.onPerformanceOptimized?.({
+                    frameRate: Math.round(currentFrameRate),
+                    memoryUsage: Math.round(memoryUsage),
+                    transitionTime: Math.round(transitionTime),
+                    smoothness: Math.round(smoothness),
+                    batteryImpact: Math.round(batteryImpact)
+                });
+            }
+            performanceTimerRef.current = requestAnimationFrame(measurePerformance);
+        };
+        performanceTimerRef.current = requestAnimationFrame(measurePerformance);
+        return () => {
+            if (performanceTimerRef.current) {
+                cancelAnimationFrame(performanceTimerRef.current);
+            }
+        };
+    }, [performance, transitionState.isTransitioning, callbacks]);
+    // Device optimization
+    const optimizeForDevice = useCallback(() => {
+        if (!deviceOptimization)
+            return;
+        const deviceType = detectDeviceType();
+        const optimizations = [];
+        switch (deviceType) {
+            case 'mobile':
+                optimizations.push('Mobile-optimized transitions (200ms max)');
+                optimizations.push('Reduced animation complexity');
+                optimizations.push('Touch-friendly timing');
+                break;
+            case 'tablet':
+                optimizations.push('Tablet-optimized transitions (300ms max)');
+                optimizations.push('Balanced performance and smoothness');
+                break;
+            case 'desktop':
+                optimizations.push('Desktop-optimized transitions (full duration)');
+                optimizations.push('Maximum visual quality');
+                break;
+        }
+        setOptimizations(prev => [...prev, ...optimizations]);
+        callbacks.onDeviceOptimized?.(deviceType);
+    }, [deviceOptimization, detectDeviceType, callbacks]);
+    // Accessibility enhancement
+    const enhanceAccessibility = useCallback(() => {
+        if (!accessibility)
+            return;
+        const enhancements = [
+            'Reduced motion support',
+            'Screen reader compatibility',
+            'Focus management during transitions',
+            'ARIA transition states',
+            'Keyboard navigation support'
+        ];
+        enhancements.forEach(enhancement => {
+            callbacks.onAccessibilityEnhanced?.(enhancement);
+        });
+    }, [accessibility, callbacks]);
+    // Auto-optimize on mount
+    const autoOptimize = useCallback(() => {
+        setIsOptimizing(true);
+        setTimeout(() => {
+            detectDeviceType();
+            detectReducedMotion();
+            detectBatteryLevel();
+            optimizeForDevice();
+            enhanceAccessibility();
+            setIsOptimizing(false);
+        }, 200);
+    }, [detectDeviceType, detectReducedMotion, detectBatteryLevel, optimizeForDevice, enhanceAccessibility]);
+    // Initialize on mount
+    useEffect(() => {
+        autoOptimize();
+        const stopPerformanceMonitoring = startPerformanceMonitoring();
+        // Listen for device changes
+        const handleResize = () => {
+            detectDeviceType();
+        };
+        // Listen for reduced motion changes
+        const mediaQuery = window.matchMedia('(prefers-reduced-motion: reduce)');
+        const handleMotionChange = () => {
+            detectReducedMotion();
+        };
+        window.addEventListener('resize', handleResize);
+        mediaQuery.addEventListener('change', handleMotionChange);
+        return () => {
+            stopPerformanceMonitoring();
+            window.removeEventListener('resize', handleResize);
+            mediaQuery.removeEventListener('change', handleMotionChange);
+        };
+    }, [autoOptimize, startPerformanceMonitoring, detectDeviceType, detectReducedMotion]);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            if (performanceTimerRef.current) {
+                cancelAnimationFrame(performanceTimerRef.current);
+            }
+        };
+    }, []);
+    return {
+        // State
+        transitionState,
+        performanceMetrics,
+        isOptimizing,
+        optimizations,
+        // Functions
+        startTransition,
+        optimizeForDevice,
+        enhanceAccessibility,
+        startPerformanceMonitoring,
+        autoOptimize,
+        // Utility functions
+        getTransitionDuration: () => transitionState.currentDuration,
+        getTransitionEasing: () => transitionState.currentEasing,
+        getTransitionDelay: () => transitionState.currentDelay,
+        isTransitionActive: () => transitionState.isTransitioning,
+        getDeviceType: () => transitionState.deviceType,
+        getBatteryLevel: () => transitionState.batteryLevel,
+        getReducedMotion: () => transitionState.reducedMotion,
+        getPerformanceScore: () => transitionState.performanceScore,
+        isPerformanceOptimal: () => transitionState.performanceScore >= 80,
+        getFrameRate: () => performanceMetrics.frameRate,
+        getSmoothness: () => performanceMetrics.smoothness,
+        getBatteryImpact: () => performanceMetrics.batteryImpact,
+        clearOptimizations: () => setOptimizations([])
+    };
+};
+export default useAdvancedTransitionSystem;

package/dist/hooks/use-animation-profile.d.ts

@@ -0,0 +1,45 @@
+export interface AnimationProfile {
+    duration: {
+        fast: string;
+        normal: string;
+        slow: string;
+    };
+    easing: {
+        ease: string;
+        easeIn: string;
+        easeOut: string;
+        easeInOut: string;
+        bounce: string;
+    };
+    performance: {
+        mode: 'high' | 'medium' | 'low';
+        batteryOptimized: boolean;
+        reducedMotion: boolean;
+    };
+}
+export interface PerformanceMetrics {
+    fps: number;
+    memoryUsage?: number;
+    batteryLevel?: number;
+    isLowPowerMode?: boolean;
+}
+export declare const useAnimationProfile: () => {
+    profile: AnimationProfile;
+    performanceMetrics: PerformanceMetrics;
+    deviceInfo: import("./use-device.js").DeviceInfo;
+    getAnimationClasses: () => string;
+    getOptimizedDuration: (type?: "fast" | "normal" | "slow") => string;
+    getOptimizedEasing: (type?: keyof AnimationProfile["easing"]) => string;
+    shouldDisableAnimations: () => boolean;
+    isReducedMotion: boolean;
+    performanceMode: string;
+    shouldOptimizeForBattery: boolean;
+};
+export declare const useAnimationDuration: (type?: "fast" | "normal" | "slow") => string;
+export declare const useAnimationEasing: (type?: keyof AnimationProfile["easing"]) => string;
+export declare const useAnimationClasses: () => string;
+export declare const usePerformanceMode: () => {
+    performanceMode: string;
+    shouldOptimizeForBattery: boolean;
+};
+//# sourceMappingURL=use-animation-profile.d.ts.map