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

package/dist/hooks/use-mobile-form-layout.js

@@ -0,0 +1,371 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+export const useMobileFormLayout = (callbacks = {}, config = {}) => {
+    const defaultConfig = {
+        enableTouchOptimization: true,
+        enableKeyboardOptimization: true,
+        enableResponsiveBehavior: true,
+        enablePerformanceOptimization: true,
+        touchTargetSize: 44,
+        spacingMultiplier: 1.2,
+        maxFieldWidth: 400,
+        enableAutoFocus: true,
+        ...config
+    };
+    const [layoutState, setLayoutState] = useState({
+        layout: {
+            isMobile: false,
+            isTablet: false,
+            isDesktop: false,
+            orientation: 'portrait',
+            keyboardVisible: false,
+            viewportHeight: window.innerHeight,
+            viewportWidth: window.innerWidth,
+            safeAreaInsets: { top: 0, bottom: 0, left: 0, right: 0 }
+        },
+        isOptimized: false,
+        currentSpacing: defaultConfig.touchTargetSize * defaultConfig.spacingMultiplier,
+        currentFieldWidth: Math.min(window.innerWidth - 32, defaultConfig.maxFieldWidth),
+        performanceMetrics: {
+            layoutUpdates: 0,
+            lastUpdateTime: 0,
+            optimizationScore: 0
+        }
+    });
+    const resizeObserverRef = useRef(null);
+    const layoutUpdateTimerRef = useRef(null);
+    const keyboardTimerRef = useRef(null);
+    // Detect device type
+    const detectDeviceType = useCallback(() => {
+        const width = window.innerWidth;
+        const userAgent = navigator.userAgent.toLowerCase();
+        let isMobile = false;
+        let isTablet = false;
+        let isDesktop = false;
+        // Check screen size
+        if (width < 768) {
+            isMobile = true;
+        }
+        else if (width < 1024) {
+            isTablet = true;
+        }
+        else {
+            isDesktop = true;
+        }
+        // Check user agent for mobile devices
+        if (/android|webos|iphone|ipad|ipod|blackberry|iemobile|opera mini/i.test(userAgent)) {
+            isMobile = true;
+            isTablet = width >= 768 && width < 1024;
+            isDesktop = false;
+        }
+        return { isMobile, isTablet, isDesktop };
+    }, []);
+    // Detect orientation
+    const detectOrientation = useCallback(() => {
+        if (window.innerHeight > window.innerWidth) {
+            return 'portrait';
+        }
+        return 'landscape';
+    }, []);
+    // Get safe area insets (for devices with notches)
+    const getSafeAreaInsets = useCallback(() => {
+        const style = getComputedStyle(document.documentElement);
+        return {
+            top: parseInt(style.getPropertyValue('--sat') || '0'),
+            bottom: parseInt(style.getPropertyValue('--sab') || '0'),
+            left: parseInt(style.getPropertyValue('--sal') || '0'),
+            right: parseInt(style.getPropertyValue('--sar') || '0')
+        };
+    }, []);
+    // Detect keyboard visibility
+    const detectKeyboardVisibility = useCallback(() => {
+        if (!defaultConfig.enableKeyboardOptimization)
+            return false;
+        const currentHeight = window.innerHeight;
+        const currentWidth = window.innerWidth;
+        // Simple heuristic: if height decreases significantly and width stays the same
+        // it's likely the keyboard appeared
+        const heightRatio = currentHeight / layoutState.layout.viewportHeight;
+        const widthRatio = currentWidth / layoutState.layout.viewportWidth;
+        return heightRatio < 0.8 && widthRatio > 0.95;
+    }, [defaultConfig.enableKeyboardOptimization, layoutState.layout.viewportHeight, layoutState.layout.viewportWidth]);
+    // Update layout state
+    const updateLayout = useCallback(() => {
+        const deviceType = detectDeviceType();
+        const orientation = detectOrientation();
+        const safeAreaInsets = getSafeAreaInsets();
+        const keyboardVisible = detectKeyboardVisibility();
+        const newLayout = {
+            ...deviceType,
+            orientation,
+            keyboardVisible,
+            viewportHeight: window.innerHeight,
+            viewportWidth: window.innerWidth,
+            safeAreaInsets
+        };
+        // Calculate optimal spacing and field width
+        let spacing = defaultConfig.touchTargetSize * defaultConfig.spacingMultiplier;
+        let fieldWidth = Math.min(window.innerWidth - 32, defaultConfig.maxFieldWidth);
+        // Adjust for mobile devices
+        if (newLayout.isMobile) {
+            spacing = Math.max(spacing, 16); // Minimum spacing for mobile
+            fieldWidth = Math.min(fieldWidth, window.innerWidth - 24); // Account for safe areas
+        }
+        // Adjust for keyboard visibility
+        if (newLayout.keyboardVisible) {
+            spacing = Math.max(spacing * 0.8, 12); // Reduce spacing when keyboard is visible
+            fieldWidth = Math.min(fieldWidth, window.innerWidth - 16);
+        }
+        // Adjust for orientation
+        if (newLayout.orientation === 'landscape' && newLayout.isMobile) {
+            spacing = Math.max(spacing * 0.9, 14);
+            fieldWidth = Math.min(fieldWidth, window.innerHeight - 24);
+        }
+        setLayoutState(prev => {
+            const newState = {
+                ...prev,
+                layout: newLayout,
+                currentSpacing: spacing,
+                currentFieldWidth: fieldWidth,
+                performanceMetrics: {
+                    ...prev.performanceMetrics,
+                    layoutUpdates: prev.performanceMetrics.layoutUpdates + 1,
+                    lastUpdateTime: Date.now()
+                }
+            };
+            // Calculate optimization score
+            const score = calculateOptimizationScore(newState);
+            newState.performanceMetrics.optimizationScore = score;
+            newState.isOptimized = score >= 0.8;
+            return newState;
+        });
+        // Notify callbacks
+        callbacks.onLayoutChange?.(newLayout);
+        callbacks.onOrientationChange?.(orientation);
+        callbacks.onKeyboardVisibilityChange?.(keyboardVisible);
+        callbacks.onViewportChange?.(window.innerWidth, window.innerHeight);
+    }, [
+        detectDeviceType,
+        detectOrientation,
+        getSafeAreaInsets,
+        detectKeyboardVisibility,
+        defaultConfig.touchTargetSize,
+        defaultConfig.spacingMultiplier,
+        defaultConfig.maxFieldWidth,
+        callbacks
+    ]);
+    // Calculate optimization score
+    const calculateOptimizationScore = useCallback((state) => {
+        let score = 0;
+        const { layout, currentSpacing, currentFieldWidth } = state;
+        // Touch target optimization (40% weight)
+        if (currentSpacing >= defaultConfig.touchTargetSize) {
+            score += 0.4;
+        }
+        else if (currentSpacing >= defaultConfig.touchTargetSize * 0.8) {
+            score += 0.3;
+        }
+        else if (currentSpacing >= defaultConfig.touchTargetSize * 0.6) {
+            score += 0.2;
+        }
+        // Field width optimization (30% weight)
+        const optimalWidth = Math.min(layout.viewportWidth - 32, defaultConfig.maxFieldWidth);
+        const widthRatio = currentFieldWidth / optimalWidth;
+        if (widthRatio >= 0.9) {
+            score += 0.3;
+        }
+        else if (widthRatio >= 0.7) {
+            score += 0.2;
+        }
+        else if (widthRatio >= 0.5) {
+            score += 0.1;
+        }
+        // Responsive behavior (20% weight)
+        if (layout.isMobile && layout.orientation === 'portrait') {
+            score += 0.2;
+        }
+        else if (layout.isMobile && layout.orientation === 'landscape') {
+            score += 0.15;
+        }
+        else if (layout.isTablet) {
+            score += 0.1;
+        }
+        // Performance optimization (10% weight)
+        if (state.performanceMetrics.layoutUpdates < 10) {
+            score += 0.1;
+        }
+        else if (state.performanceMetrics.layoutUpdates < 20) {
+            score += 0.05;
+        }
+        return Math.min(score, 1);
+    }, [defaultConfig.touchTargetSize, defaultConfig.maxFieldWidth]);
+    // Debounced layout update
+    const debouncedUpdateLayout = useCallback(() => {
+        if (layoutUpdateTimerRef.current) {
+            clearTimeout(layoutUpdateTimerRef.current);
+        }
+        layoutUpdateTimerRef.current = setTimeout(() => {
+            updateLayout();
+        }, 100); // 100ms debounce
+    }, [updateLayout]);
+    // Handle window resize
+    const handleResize = useCallback(() => {
+        if (defaultConfig.enableResponsiveBehavior) {
+            debouncedUpdateLayout();
+        }
+    }, [defaultConfig.enableResponsiveBehavior, debouncedUpdateLayout]);
+    // Handle orientation change
+    const handleOrientationChange = useCallback(() => {
+        if (defaultConfig.enableResponsiveBehavior) {
+            // Add delay for orientation change to complete
+            setTimeout(() => {
+                updateLayout();
+            }, 300);
+        }
+    }, [defaultConfig.enableResponsiveBehavior, updateLayout]);
+    // Handle keyboard visibility changes
+    const handleKeyboardChange = useCallback(() => {
+        if (defaultConfig.enableKeyboardOptimization) {
+            if (keyboardTimerRef.current) {
+                clearTimeout(keyboardTimerRef.current);
+            }
+            keyboardTimerRef.current = setTimeout(() => {
+                updateLayout();
+            }, 150); // Small delay to detect keyboard changes
+        }
+    }, [defaultConfig.enableKeyboardOptimization, updateLayout]);
+    // Set up resize observer for more precise layout detection
+    useEffect(() => {
+        if (defaultConfig.enablePerformanceOptimization && 'ResizeObserver' in window) {
+            resizeObserverRef.current = new ResizeObserver(() => {
+                handleResize();
+            });
+            resizeObserverRef.current.observe(document.body);
+        }
+        return () => {
+            if (resizeObserverRef.current) {
+                resizeObserverRef.current.disconnect();
+            }
+        };
+    }, [defaultConfig.enablePerformanceOptimization, handleResize]);
+    // Set up window event listeners
+    useEffect(() => {
+        if (defaultConfig.enableResponsiveBehavior) {
+            window.addEventListener('resize', handleResize);
+            window.addEventListener('orientationchange', handleOrientationChange);
+            // Listen for visual viewport changes (better for mobile)
+            if ('visualViewport' in window) {
+                window.visualViewport.addEventListener('resize', handleKeyboardChange);
+            }
+        }
+        return () => {
+            window.removeEventListener('resize', handleResize);
+            window.removeEventListener('orientationchange', handleOrientationChange);
+            if ('visualViewport' in window) {
+                window.visualViewport.removeEventListener('resize', handleKeyboardChange);
+            }
+        };
+    }, [defaultConfig.enableResponsiveBehavior, handleResize, handleOrientationChange, handleKeyboardChange]);
+    // Initial layout detection
+    useEffect(() => {
+        updateLayout();
+    }, [updateLayout]);
+    // Get CSS classes for layout optimization
+    const getLayoutClasses = useCallback(() => {
+        const { layout, isOptimized } = layoutState;
+        const classes = ['mobile-form-layout'];
+        if (layout.isMobile) {
+            classes.push('layout-mobile');
+            if (layout.orientation === 'portrait') {
+                classes.push('layout-portrait');
+            }
+            else {
+                classes.push('layout-landscape');
+            }
+        }
+        else if (layout.isTablet) {
+            classes.push('layout-tablet');
+        }
+        else {
+            classes.push('layout-desktop');
+        }
+        if (layout.keyboardVisible) {
+            classes.push('layout-keyboard-visible');
+        }
+        if (isOptimized) {
+            classes.push('layout-optimized');
+        }
+        return classes.join(' ');
+    }, [layoutState]);
+    // Get CSS variables for dynamic styling
+    const getLayoutCSSVariables = useCallback(() => {
+        const { currentSpacing, currentFieldWidth } = layoutState;
+        return {
+            '--mobile-spacing': `${currentSpacing}px`,
+            '--mobile-field-width': `${currentFieldWidth}px`,
+            '--touch-target-size': `${defaultConfig.touchTargetSize}px`,
+            '--safe-area-top': `${layoutState.layout.safeAreaInsets.top}px`,
+            '--safe-area-bottom': `${layoutState.layout.safeAreaInsets.bottom}px`,
+            '--safe-area-left': `${layoutState.layout.safeAreaInsets.left}px`,
+            '--safe-area-right': `${layoutState.layout.safeAreaInsets.right}px`
+        };
+    }, [layoutState, defaultConfig.touchTargetSize]);
+    // Auto-focus first input when layout changes
+    const autoFocusFirstInput = useCallback(() => {
+        if (!defaultConfig.enableAutoFocus)
+            return;
+        const firstInput = document.querySelector('input, textarea, select');
+        if (firstInput && layoutState.layout.isMobile) {
+            // Small delay to ensure layout is stable
+            setTimeout(() => {
+                firstInput.focus();
+            }, 100);
+        }
+    }, [defaultConfig.enableAutoFocus, layoutState.layout.isMobile]);
+    // Clean up timers on unmount
+    useEffect(() => {
+        return () => {
+            if (layoutUpdateTimerRef.current) {
+                clearTimeout(layoutUpdateTimerRef.current);
+            }
+            if (keyboardTimerRef.current) {
+                clearTimeout(keyboardTimerRef.current);
+            }
+        };
+    }, []);
+    return {
+        layoutState,
+        updateLayout,
+        getLayoutClasses,
+        getLayoutCSSVariables,
+        autoFocusFirstInput,
+        isMobile: layoutState.layout.isMobile,
+        isTablet: layoutState.layout.isTablet,
+        isDesktop: layoutState.layout.isDesktop,
+        orientation: layoutState.layout.orientation,
+        keyboardVisible: layoutState.layout.keyboardVisible,
+        currentSpacing: layoutState.currentSpacing,
+        currentFieldWidth: layoutState.currentFieldWidth,
+        isOptimized: layoutState.isOptimized,
+        performanceMetrics: layoutState.performanceMetrics
+    };
+};
+// Convenience hook for basic mobile layout
+export const useBasicMobileLayout = () => {
+    return useMobileFormLayout({}, {
+        enableTouchOptimization: true,
+        enableKeyboardOptimization: false,
+        enableResponsiveBehavior: true,
+        enablePerformanceOptimization: false,
+        enableAutoFocus: false
+    });
+};
+// Convenience hook for enhanced mobile layout
+export const useEnhancedMobileLayout = () => {
+    return useMobileFormLayout({}, {
+        enableTouchOptimization: true,
+        enableKeyboardOptimization: true,
+        enableResponsiveBehavior: true,
+        enablePerformanceOptimization: true,
+        enableAutoFocus: true
+    });
+};

package/dist/hooks/use-mobile-form-validation.d.ts

@@ -0,0 +1,100 @@
+export interface ValidationRule {
+    type: 'required' | 'email' | 'minLength' | 'maxLength' | 'pattern' | 'custom';
+    value?: string | number | RegExp;
+    message: string;
+    validator?: (value: any) => boolean | Promise<boolean>;
+}
+export interface ValidationState {
+    isValid: boolean;
+    errors: string[];
+    isDirty: boolean;
+    isTouched: boolean;
+    isSubmitting: boolean;
+    isSubmitted: boolean;
+}
+export interface FormField {
+    name: string;
+    value: any;
+    rules: ValidationRule[];
+    validationState: ValidationState;
+}
+export interface MobileFormValidationConfig {
+    enableTouchFeedback: boolean;
+    enableHapticFeedback: boolean;
+    enableSoundFeedback: boolean;
+    validationDelay: number;
+    enablePerformanceOptimization: boolean;
+    maxValidationRetries: number;
+}
+export interface ValidationCallbacks {
+    onValidationStart?: (fieldName: string) => void;
+    onValidationComplete?: (fieldName: string, isValid: boolean, errors: string[]) => void;
+    onFormSubmit?: (formData: Record<string, any>, isValid: boolean) => void;
+    onValidationError?: (fieldName: string, errors: string[]) => void;
+    onValidationSuccess?: (fieldName: string) => void;
+}
+export interface MobileFormValidationState {
+    fields: Record<string, FormField>;
+    overallValidation: ValidationState;
+    isOptimized: boolean;
+    performanceMetrics: {
+        validationCount: number;
+        averageValidationTime: number;
+        lastValidationTime: number;
+    };
+}
+export declare const useMobileFormValidation: (initialFields: Record<string, Omit<FormField, "validationState">>, callbacks?: ValidationCallbacks, config?: Partial<MobileFormValidationConfig>) => {
+    validationState: MobileFormValidationState;
+    updateField: (fieldName: string, value: any, shouldValidate?: boolean) => void;
+    touchField: (fieldName: string) => void;
+    validateField: (fieldName: string, value: any, rules: ValidationRule[]) => void;
+    validateAllFields: () => Promise<boolean>;
+    submitForm: () => Promise<{
+        success: boolean;
+        data: Record<string, any>;
+        errors: string[];
+    }>;
+    resetForm: () => void;
+    getFieldValidation: (fieldName: string) => ValidationState;
+    isFormValid: boolean;
+    isFormDirty: boolean;
+    triggerHapticFeedback: (intensity?: "light" | "medium" | "strong") => void;
+    triggerSoundFeedback: (type?: "success" | "error") => void;
+};
+export declare const useBasicFormValidation: (initialFields: Record<string, Omit<FormField, "validationState">>) => {
+    validationState: MobileFormValidationState;
+    updateField: (fieldName: string, value: any, shouldValidate?: boolean) => void;
+    touchField: (fieldName: string) => void;
+    validateField: (fieldName: string, value: any, rules: ValidationRule[]) => void;
+    validateAllFields: () => Promise<boolean>;
+    submitForm: () => Promise<{
+        success: boolean;
+        data: Record<string, any>;
+        errors: string[];
+    }>;
+    resetForm: () => void;
+    getFieldValidation: (fieldName: string) => ValidationState;
+    isFormValid: boolean;
+    isFormDirty: boolean;
+    triggerHapticFeedback: (intensity?: "light" | "medium" | "strong") => void;
+    triggerSoundFeedback: (type?: "success" | "error") => void;
+};
+export declare const useEnhancedFormValidation: (initialFields: Record<string, Omit<FormField, "validationState">>) => {
+    validationState: MobileFormValidationState;
+    updateField: (fieldName: string, value: any, shouldValidate?: boolean) => void;
+    touchField: (fieldName: string) => void;
+    validateField: (fieldName: string, value: any, rules: ValidationRule[]) => void;
+    validateAllFields: () => Promise<boolean>;
+    submitForm: () => Promise<{
+        success: boolean;
+        data: Record<string, any>;
+        errors: string[];
+    }>;
+    resetForm: () => void;
+    getFieldValidation: (fieldName: string) => ValidationState;
+    isFormValid: boolean;
+    isFormDirty: boolean;
+    triggerHapticFeedback: (intensity?: "light" | "medium" | "strong") => void;
+    triggerSoundFeedback: (type?: "success" | "error") => void;
+};
+//# sourceMappingURL=use-mobile-form-validation.d.ts.map

package/dist/hooks/use-mobile-form-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-mobile-form-validation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-mobile-form-validation.ts"],"names":[],"mappings":"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"}