@djangocfg/layouts 2.1.10 → 2.1.14

package/src/auth/context/AuthContext.tsx

@@ -1,604 +0,0 @@
-// @ts-nocheck
-'use client';
-
-import { usePathname } from 'next/navigation';
-import React, {
-    createContext, ReactNode, useCallback, useContext, useEffect, useMemo, useRef, useState
-} from 'react';
-
-import { api, Enums } from '@djangocfg/api';
-import { useAccountsContext, AccountsProvider } from './AccountsContext';
-import { useLocalStorage, useQueryParams, useCfgRouter } from '@djangocfg/ui-nextjs/hooks';
-import { getCachedProfile, clearProfileCache } from '../hooks/useProfileCache';
-
-import { authLogger } from '../../utils/logger';
-import { Analytics, AnalyticsEvent, AnalyticsCategory } from '../../snippets/Analytics';
-import type { AuthConfig, AuthContextType, AuthProviderProps, UserProfile } from './types';
-
-// Default routes
-const defaultRoutes = {
-  auth: '/auth',
-  defaultCallback: '/dashboard',
-  defaultAuthCallback: '/auth',
-};
-
-const AuthContext = createContext<AuthContextType | undefined>(undefined);
-
-// Constants
-const EMAIL_STORAGE_KEY = 'auth_email';
-const PHONE_STORAGE_KEY = 'auth_phone';
-const AUTH_REDIRECT_KEY = 'auth_redirect_url';
-
-const hasValidTokens = (): boolean => {
-  if (typeof window === 'undefined') return false;
-  return api.isAuthenticated();
-};
-
-// Internal provider that uses AccountsContext
-const AuthProviderInternal: React.FC<AuthProviderProps> = ({ children, config }) => {
-  const accounts = useAccountsContext();
-
-  // Smart initial loading state: only true if we don't have tokens yet
-  const [isLoading, setIsLoading] = useState(() => {
-    // If we already have tokens and profile, don't show loading
-    if (typeof window !== 'undefined') {
-      const hasTokens = hasValidTokens();
-      // Only show loading on initial mount if no tokens
-      return !hasTokens;
-    }
-    return true;
-  });
-
-  const [initialized, setInitialized] = useState(false);
-  const router = useCfgRouter();
-  const pathname = usePathname();
-  const queryParams = useQueryParams();
-
-  // Use localStorage hooks for email, phone, and redirect
-  const [storedEmail, setStoredEmail, clearStoredEmail] = useLocalStorage<string | null>(EMAIL_STORAGE_KEY, null);
-  const [storedPhone, setStoredPhone, clearStoredPhone] = useLocalStorage<string | null>(PHONE_STORAGE_KEY, null);
-  const [redirectUrl, setRedirectUrl, clearRedirectUrl] = useLocalStorage<string | null>(AUTH_REDIRECT_KEY, null);
-
-  // Map AccountsContext profile to UserProfile
-  const user = accounts.profile as UserProfile | null;
-
-  // Use refs to avoid dependency issues
-  const userRef = useRef(user);
-  const configRef = useRef(config);
-  const isLoadingProfileRef = useRef(false);
-
-  // Update refs when values change
-  useEffect(() => {
-    userRef.current = user;
-  }, [user]);
-
-  useEffect(() => {
-    configRef.current = config;
-  }, [config]);
-
-  // Note: API URL is configured in BaseClient, not at runtime
-
-  // Common function to clear auth state
-  const clearAuthState = useCallback((caller: string) => {
-    authLogger.info('clearAuthState >> caller', caller);
-    api.clearTokens();
-    clearProfileCache(); // Clear profile cache from localStorage
-    // Note: user is now managed by AccountsContext, will auto-update
-    setInitialized(true);
-    setIsLoading(false);
-  }, []);
-
-  // Global error handler for auth-related errors
-  const handleGlobalAuthError = useCallback((error: any, context: string = 'API Request') => {
-    // Simple error check - if response has error flag, it's an error
-    if (error?.success === false) {
-      authLogger.warn(`Error detected in ${context}, clearing tokens`);
-      clearAuthState(`globalAuthError:${context}`);
-      return true;
-    }
-
-    return false;
-  }, [clearAuthState]);
-
-  // Simple profile loading without retry - now uses AccountsContext with memoization
-  const loadCurrentProfile = useCallback(async (callerId?: string): Promise<void> => {
-    const finalCallerId = callerId || 'AuthContext.loadCurrentProfile';
-
-    // Check if profile loading is already in progress
-    if (isLoadingProfileRef.current) {
-      authLogger.debug(`Profile loading already in progress, skipping duplicate call from: ${finalCallerId}`);
-      return;
-    }
-
-    authLogger.debug(`loadCurrentProfile called by: ${finalCallerId}`);
-
-    try {
-      isLoadingProfileRef.current = true;
-
-      // Ensure API clients are properly initialized with current token
-      const isAuth = api.isAuthenticated();
-      const token = api.getToken();
-      // authLogger.debug('isAuthenticated:', isAuth, 'token:', token ? token.substring(0, 20) + '...' : 'null');
-
-      if (!isAuth) {
-        authLogger.warn('No valid authentication token, throwing error');
-        throw new Error('No valid authentication token');
-      }
-
-      // Check if profile is already loaded in AccountsContext to prevent duplicate API calls
-      if (accounts.profile && !accounts.isLoadingProfile) {
-        authLogger.debug('Profile already loaded in AccountsContext, skipping API call');
-        setInitialized(true);
-        return;
-      }
-
-      // Refresh profile from AccountsContext (now with memoization)
-      const refreshedProfile = await accounts.refreshProfile(finalCallerId);
-
-      if (refreshedProfile) {
-        authLogger.info('Profile loaded successfully:', refreshedProfile.id);
-      } else {
-        authLogger.warn('Profile refresh returned undefined - but keeping tokens');
-      }
-
-      // Always mark as initialized if we have valid tokens
-      // Don't clear tokens just because profile fetch failed
-      setInitialized(true);
-    } catch (error) {
-      authLogger.error('Failed to load profile:', error);
-      // Use global error handler first, fallback to clearing state
-      if (!handleGlobalAuthError(error, 'loadCurrentProfile')) {
-        clearAuthState('loadCurrentProfile:error');
-      }
-    } finally {
-      isLoadingProfileRef.current = false;
-    }
-  }, [clearAuthState, handleGlobalAuthError, accounts]);
-
-  // Initialize auth state once
-  useEffect(() => {
-    if (initialized) return;
-
-    const initializeAuth = async () => {
-      authLogger.info('Initializing auth...');
-
-      // Check if running in iframe (AdminLayout will handle auth via postMessage)
-      const isInIframe = typeof window !== 'undefined' && window.self !== window.top;
-      authLogger.info('Is in iframe:', isInIframe);
-
-      // Debug token state
-      const token = api.getToken();
-      const refreshToken = api.getRefreshToken();
-      authLogger.info('Token from API:', token ? `${token.substring(0, 20)}...` : 'null');
-      authLogger.info('Refresh token from API:', refreshToken ? `${refreshToken.substring(0, 20)}...` : 'null');
-      authLogger.info('localStorage keys:', Object.keys(localStorage).filter(k => k.includes('token') || k.includes('auth')));
-
-      const hasTokens = hasValidTokens();
-      authLogger.info('Has tokens:', hasTokens);
-
-      // Check if profile is already loaded from cache (AccountsContext initialization)
-      if (userRef.current) {
-        authLogger.info('Profile already loaded from AccountsContext cache, skipping API request');
-        setInitialized(true);
-        setIsLoading(false);
-        return;
-      }
-
-      // Check if cache exists in localStorage (before userRef updates)
-      const cachedProfile = getCachedProfile();
-      if (cachedProfile) {
-        authLogger.info('Profile found in localStorage cache, skipping API request');
-        setInitialized(true);
-        setIsLoading(false);
-        return;
-      }
-
-      // In iframe mode WITHOUT tokens yet - wait for AdminLayout to receive them via postMessage
-      // Don't initialize yet - AdminLayout.handleAuthToken will call loadCurrentProfile
-      if (isInIframe && !hasTokens) {
-        authLogger.info('Running in iframe without tokens - waiting for parent to send via postMessage');
-        authLogger.info('AdminLayout will handle auth initialization, skipping AuthContext init');
-        setInitialized(true); // Mark as initialized to prevent re-initialization
-        setIsLoading(false);
-        return;
-      }
-
-      if (hasTokens) {
-        setIsLoading(true);
-        try {
-          authLogger.info('No cached profile found, loading from API...');
-          await loadCurrentProfile('AuthContext.initializeAuth');
-        } catch (error) {
-          authLogger.error('Failed to load profile during initialization:', error);
-          // If profile loading fails, clear auth state
-          clearAuthState('initializeAuth:loadProfileFailed');
-        }
-        setIsLoading(false);
-      } else {
-        setInitialized(true);
-        setIsLoading(false);
-      }
-    };
-
-    initializeAuth();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [initialized]);
-
-  // Redirect logic - only for unauthenticated users on protected pages
-  useEffect(() => {
-    if (!initialized) return;
-
-    // Consider authenticated if we have valid tokens, even without profile
-    const isAuthenticated = api.isAuthenticated();
-    const authRoute = config?.routes?.auth || defaultRoutes.auth;
-    const isAuthPage = pathname === authRoute;
-    const flowParam = queryParams.get('flow');
-
-    // Only redirect authenticated users away from auth page if they're not in a flow
-    // This prevents interference with OTP verification flow
-    if (isAuthenticated && isAuthPage && !flowParam) {
-      const callbackUrl = config?.routes?.defaultCallback || defaultRoutes.defaultCallback;
-      router.push(callbackUrl);
-    }
-  }, [initialized, pathname, queryParams, config?.routes]);
-
-  const pushToDefaultCallbackUrl = useCallback(() => {
-    const callbackUrl = config?.routes?.defaultCallback || defaultRoutes.defaultCallback;
-    router.push(callbackUrl);
-  }, [config?.routes, router]);
-
-  const pushToDefaultAuthCallbackUrl = useCallback(() => {
-    const authCallbackUrl = config?.routes?.defaultAuthCallback || defaultRoutes.defaultAuthCallback;
-    router.push(authCallbackUrl);
-  }, [config?.routes, router]);
-
-  // Memoized checkAuthAndRedirect function
-  const checkAuthAndRedirect = useCallback(async () => {
-    try {
-      setIsLoading(true);
-      const isAuthenticated = api.isAuthenticated();
-
-      if (isAuthenticated) {
-        await loadCurrentProfile();
-        if (userRef.current) {
-          pushToDefaultCallbackUrl();
-        }
-      } else {
-        pushToDefaultAuthCallbackUrl();
-      }
-    } catch (error) {
-      authLogger.error('Failed to check authentication:', error);
-      // Use global error handler first
-      if (!handleGlobalAuthError(error, 'checkAuthAndRedirect')) {
-        clearAuthState('checkAuthAndRedirect');
-      }
-      pushToDefaultAuthCallbackUrl();
-    } finally {
-      setIsLoading(false);
-    }
-  }, [loadCurrentProfile, clearAuthState, pushToDefaultCallbackUrl, pushToDefaultAuthCallbackUrl, handleGlobalAuthError]);
-
-  // OTP methods - supports both email and phone - now uses AccountsContext
-  const requestOTP = useCallback(
-    async (identifier: string, channel?: 'email' | 'phone', sourceUrl?: string): Promise<{ success: boolean; message: string }> => {
-      // Clear tokens before requesting OTP
-      api.clearTokens();
-
-      try {
-        const channelValue = channel === 'phone' 
-          ? Enums.OTPRequestRequestChannel.PHONE 
-          : Enums.OTPRequestRequestChannel.EMAIL;
-        const result = await accounts.requestOTP({
-          identifier,
-          channel: channelValue,
-        });
-
-        const channelName = channel === 'phone' ? 'phone number' : 'email address';
-
-        // Track OTP request
-        Analytics.event(AnalyticsEvent.AUTH_OTP_REQUEST, {
-          category: AnalyticsCategory.AUTH,
-          label: channel || 'email',
-        });
-
-        return {
-          success: true,
-          message: result.message || `OTP code sent to your ${channelName}`,
-        };
-      } catch (error) {
-        authLogger.error('Request OTP error:', error);
-        return {
-          success: false,
-          message: 'Failed to send OTP',
-        };
-      }
-    },
-    [accounts],
-  );
-
-  const verifyOTP = useCallback(
-    async (identifier: string, otpCode: string, channel?: 'email' | 'phone', sourceUrl?: string): Promise<{ success: boolean; message: string; user?: UserProfile }> => {
-      try {
-        const channelValue = channel === 'phone' 
-          ? Enums.OTPVerifyRequestChannel.PHONE 
-          : Enums.OTPVerifyRequestChannel.EMAIL;
-        // AccountsContext automatically saves tokens and refreshes profile
-        const result = await accounts.verifyOTP({
-          identifier,
-          otp: otpCode,
-          channel: channelValue,
-        });
-
-        // Verify that we got valid tokens
-        if (!result.access || !result.refresh) {
-          authLogger.error('Verify OTP returned invalid response:', result);
-          return {
-            success: false,
-            message: 'Invalid OTP verification response',
-          };
-        }
-
-        // Save identifier based on channel and clear opposite channel
-        if (channel === 'phone') {
-          setStoredPhone(identifier);
-          clearStoredEmail();
-        } else if (identifier.includes('@')) {
-          setStoredEmail(identifier);
-          clearStoredPhone();
-        }
-
-        // Small delay to ensure profile state is updated
-        await new Promise(resolve => setTimeout(resolve, 200));
-
-        // Track successful login
-        Analytics.event(AnalyticsEvent.AUTH_LOGIN_SUCCESS, {
-          category: AnalyticsCategory.AUTH,
-          label: channel || 'email',
-        });
-
-        // Set user ID for future tracking
-        if (result.user?.id) {
-          Analytics.setUser(String(result.user.id));
-        }
-
-        // Handle redirect logic here
-        // Use hardPush for full page reload - ensures all React contexts reinitialize
-        const defaultCallback = config?.routes?.defaultCallback || defaultRoutes.defaultCallback;
-
-        if (redirectUrl && redirectUrl !== defaultCallback) {
-          clearRedirectUrl();
-          router.hardPush(redirectUrl);
-        } else {
-          router.hardPush(defaultCallback);
-        }
-
-        return {
-          success: true,
-          message: 'Login successful',
-          user: result.user as UserProfile,
-        };
-      } catch (error) {
-        authLogger.error('Verify OTP error:', error);
-
-        // Track failed verification
-        Analytics.event(AnalyticsEvent.AUTH_OTP_VERIFY_FAIL, {
-          category: AnalyticsCategory.AUTH,
-          label: channel || 'email',
-        });
-
-        return {
-          success: false,
-          message: 'Failed to verify OTP',
-        };
-      }
-    },
-    [setStoredEmail, setStoredPhone, clearStoredEmail, clearStoredPhone, redirectUrl, clearRedirectUrl, config?.routes?.defaultCallback, accounts],
-  );
-
-  const refreshToken = useCallback(async (): Promise<{ success: boolean; message: string }> => {
-    try {
-      const refreshTokenValue = api.getRefreshToken();
-      if (!refreshTokenValue) {
-        clearAuthState('refreshToken:noToken');
-
-        // Track session expired
-        Analytics.event(AnalyticsEvent.AUTH_SESSION_EXPIRED, {
-          category: AnalyticsCategory.AUTH,
-        });
-
-        return {
-          success: false,
-          message: 'No refresh token available',
-        };
-      }
-
-      await accounts.refreshToken(refreshTokenValue);
-
-      // Track successful refresh
-      Analytics.event(AnalyticsEvent.AUTH_TOKEN_REFRESH, {
-        category: AnalyticsCategory.AUTH,
-      });
-
-      return {
-        success: true,
-        message: 'Token refreshed',
-      };
-    } catch (error) {
-      authLogger.error('Refresh token error:', error);
-      clearAuthState('refreshToken:error');
-
-      // Track refresh failure
-      Analytics.event(AnalyticsEvent.AUTH_TOKEN_REFRESH_FAIL, {
-        category: AnalyticsCategory.AUTH,
-      });
-
-      return {
-        success: false,
-        message: 'Error refreshing token',
-      };
-    }
-  }, [clearAuthState, accounts]);
-
-  const clearRedirect = useCallback((): void => {
-    clearRedirectUrl();
-  }, [clearRedirectUrl]);
-
-  // Save current URL for redirect after authentication
-  const saveCurrentUrlForRedirect = useCallback((): void => {
-    if (typeof window !== 'undefined') {
-      const currentUrl = window.location.pathname + window.location.search;
-      setRedirectUrl(currentUrl);
-    }
-  }, [setRedirectUrl]);
-
-  const logout = useCallback(async (): Promise<void> => {
-    const performLogout = () => {
-      // Track logout
-      Analytics.event(AnalyticsEvent.AUTH_LOGOUT, {
-        category: AnalyticsCategory.AUTH,
-      });
-
-      accounts.logout(); // Clear tokens and profile
-      setInitialized(true);
-      setIsLoading(false);
-
-      // Use hardReplace for full page reload + replace history
-      // This ensures contexts reinitialize AND back button won't return to protected page
-      const authCallbackUrl = config?.routes?.defaultAuthCallback || defaultRoutes.defaultAuthCallback;
-      router.hardReplace(authCallbackUrl);
-    };
-
-    // Use config.onConfirm if provided, otherwise use a simple confirm
-    if (configRef.current?.onConfirm) {
-      const { confirmed } = await configRef.current.onConfirm({
-        title: 'Logout',
-        description: 'Are you sure you want to logout?',
-        confirmationButtonText: 'Logout',
-        cancellationButtonText: 'Cancel',
-        color: 'error',
-      });
-      if (confirmed) {
-        performLogout();
-      }
-    } else {
-      // Fallback to browser confirm
-      const confirmed = window.confirm('Are you sure you want to logout?');
-      if (confirmed) {
-        performLogout();
-      }
-    }
-  }, [accounts, config?.routes?.defaultAuthCallback, router]);
-
-  // Redirect URL methods
-  const getSavedRedirectUrl = useCallback((): string | null => {
-    if (typeof window !== 'undefined') {
-      return sessionStorage.getItem(AUTH_REDIRECT_KEY);
-    }
-    return null;
-  }, []);
-
-  const saveRedirectUrl = useCallback((url: string): void => {
-    if (typeof window !== 'undefined') {
-      sessionStorage.setItem(AUTH_REDIRECT_KEY, url);
-    }
-  }, []);
-
-  const clearSavedRedirectUrl = useCallback((): void => {
-    if (typeof window !== 'undefined') {
-      sessionStorage.removeItem(AUTH_REDIRECT_KEY);
-    }
-  }, []);
-
-  const getFinalRedirectUrl = useCallback((): string => {
-    const savedUrl = getSavedRedirectUrl();
-    return savedUrl || (config?.routes?.defaultCallback || defaultRoutes.defaultCallback);
-  }, [getSavedRedirectUrl, config?.routes?.defaultCallback]);
-
-  const useAndClearRedirectUrl = useCallback((): string => {
-    const finalUrl = getFinalRedirectUrl();
-    clearSavedRedirectUrl();
-    return finalUrl;
-  }, [getFinalRedirectUrl, clearSavedRedirectUrl]);
-
-  // Computed: Is admin user (staff or superuser)
-  const isAdminUser = useMemo(() => {
-    return Boolean(user?.is_staff || user?.is_superuser);
-  }, [user]);
-
-  // Memoized context value
-  const value = useMemo<AuthContextType>(
-    () => ({
-      user,
-      isLoading,
-      // Consider authenticated if we have valid tokens, even without user profile
-      isAuthenticated: api.isAuthenticated(),
-      isAdminUser,
-      loadCurrentProfile,
-      checkAuthAndRedirect,
-      getToken: () => api.getToken(),
-      getRefreshToken: () => api.getRefreshToken(),
-      getSavedEmail: () => storedEmail,
-      saveEmail: setStoredEmail,
-      clearSavedEmail: clearStoredEmail,
-      getSavedPhone: () => storedPhone,
-      savePhone: setStoredPhone,
-      clearSavedPhone: clearStoredPhone,
-      requestOTP,
-      verifyOTP,
-      refreshToken,
-      logout,
-      getSavedRedirectUrl,
-      saveRedirectUrl,
-      clearSavedRedirectUrl,
-      getFinalRedirectUrl,
-      useAndClearRedirectUrl,
-      saveCurrentUrlForRedirect,
-    }),
-    [
-      user,
-      isLoading,
-      isAdminUser,
-      loadCurrentProfile,
-      checkAuthAndRedirect,
-      storedEmail,
-      setStoredEmail,
-      clearStoredEmail,
-      storedPhone,
-      setStoredPhone,
-      clearStoredPhone,
-      requestOTP,
-      verifyOTP,
-      refreshToken,
-      logout,
-      getSavedRedirectUrl,
-      saveRedirectUrl,
-      clearSavedRedirectUrl,
-      getFinalRedirectUrl,
-      useAndClearRedirectUrl,
-      saveCurrentUrlForRedirect,
-    ],
-  );
-
-  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
-};
-
-// Wrapper that provides AccountsContext
-export const AuthProvider: React.FC<AuthProviderProps> = ({ children, config }) => {
-  return (
-    <AccountsProvider>
-      <AuthProviderInternal config={config}>
-        {children}
-      </AuthProviderInternal>
-    </AccountsProvider>
-  );
-};
-
-export const useAuth = (): AuthContextType => {
-  const context = useContext(AuthContext);
-  if (context === undefined) {
-    throw new Error('useAuth must be used within an AuthProvider');
-  }
-  return context;
-};
-
-export default AuthContext; 

package/src/auth/context/index.ts

@@ -1,4 +0,0 @@
-export { AuthProvider, useAuth } from './AuthContext';
-export type { AuthConfig, AuthContextType, AuthProviderProps, UserProfile } from './types';
-export { AccountsProvider, useAccountsContext, PatchedUserProfileUpdateRequestSchema } from './AccountsContext';
-export type { AccountsContextValue, PatchedUserProfileUpdateRequest } from './AccountsContext'; 

package/src/auth/context/types.ts

@@ -1,68 +0,0 @@
-import React from 'react';
-
-import type { CfgUserProfileTypes } from '@djangocfg/api';
-
-// User profile type
-export type UserProfile = CfgUserProfileTypes.User;
-
-// Auth configuration
-export interface AuthConfig {
-  apiUrl?: string;
-  routes?: {
-    auth?: string;
-    defaultCallback?: string;
-    defaultAuthCallback?: string;
-  };
-  onLogout?: () => void;
-  onConfirm?: (options: {
-    title: string;
-    description: string;
-    confirmationButtonText: string;
-    cancellationButtonText: string;
-    color: string;
-  }) => Promise<{ confirmed: boolean }>;
-}
-
-// Auth context interface
-export interface AuthContextType {
-  user: UserProfile | null;
-  isLoading: boolean;
-  isAuthenticated: boolean;
-  isAdminUser: boolean;
-  loadCurrentProfile: (callerId?: string) => Promise<void>;
-  checkAuthAndRedirect: () => Promise<void>;
-
-  // Token Methods
-  getToken: () => string | null;
-  getRefreshToken: () => string | null;
-
-  // Email Methods
-  getSavedEmail: () => string | null;
-  saveEmail: (email: string) => void;
-  clearSavedEmail: () => void;
-
-  // Phone Methods
-  getSavedPhone: () => string | null;
-  savePhone: (phone: string) => void;
-  clearSavedPhone: () => void;
-
-  // OTP Methods - Multi-channel support
-  requestOTP: (identifier: string, channel?: 'email' | 'phone', sourceUrl?: string) => Promise<{ success: boolean; message: string }>;
-  verifyOTP: (identifier: string, otpCode: string, channel?: 'email' | 'phone', sourceUrl?: string) => Promise<{ success: boolean; message: string; user?: UserProfile }>;
-  refreshToken: () => Promise<{ success: boolean; message: string }>;
-  logout: () => Promise<void>;
-
-  // Redirect Methods
-  getSavedRedirectUrl: () => string | null;
-  saveRedirectUrl: (url: string) => void;
-  clearSavedRedirectUrl: () => void;
-  getFinalRedirectUrl: () => string;
-  useAndClearRedirectUrl: () => string;
-  saveCurrentUrlForRedirect: () => void;
-}
-
-// Provider props
-export interface AuthProviderProps {
-  children: React.ReactNode;
-  config?: AuthConfig;
-} 

package/src/auth/hooks/index.ts

@@ -1,17 +0,0 @@
-'use client';
-
-export { useAuthRedirectManager } from './useAuthRedirect';
-export { useAuthGuard } from './useAuthGuard';
-export { useSessionStorage } from './useSessionStorage';
-export { useLocalStorage } from './useLocalStorage';
-export { useAuthForm } from './useAuthForm';
-export { useAutoAuth } from './useAutoAuth';
-export { useGithubAuth, type UseGithubAuthOptions, type UseGithubAuthReturn } from './useGithubAuth';
-export {
-  getCachedProfile,
-  setCachedProfile,
-  clearProfileCache,
-  hasValidCache,
-  getCacheMetadata,
-  type ProfileCacheOptions
-} from './useProfileCache';