@djangocfg/api 2.1.227 → 2.1.229

package/src/auth/context/AuthContext.tsx

@@ -9,7 +9,8 @@ import { SWRConfig } from 'swr';
 
 import { useCfgRouter, useLocalStorage, useQueryParams } from '../hooks';
 
-import { api as apiAccounts, Enums } from '../../';
+import { api as apiAccounts } from '../../';
+import { APIError } from '../../_api/generated/cfg_accounts/errors';
 import { clearProfileCache, getCachedProfile } from '../hooks/useProfileCache';
 import { useAuthRedirectManager } from '../hooks/useAuthRedirect';
 import { useTokenRefresh } from '../hooks/useTokenRefresh';
@@ -30,7 +31,6 @@ const AuthContext = createContext<AuthContextType | undefined>(undefined);
 
 // Constants
 const EMAIL_STORAGE_KEY = 'auth_email';
-const PHONE_STORAGE_KEY = 'auth_phone';
 
 const hasValidTokens = (): boolean => {
   if (typeof window === 'undefined') return false;
@@ -63,9 +63,8 @@ const AuthProviderInternal: React.FC<AuthProviderProps> = ({ children, config })
   const pathname = usePathname();
   const queryParams = useQueryParams();
 
-  // Use localStorage hooks for email and phone
+  // Use localStorage hook for email
   const [storedEmail, setStoredEmail, clearStoredEmail] = useLocalStorage<string | null>(EMAIL_STORAGE_KEY, null);
-  const [storedPhone, setStoredPhone, clearStoredPhone] = useLocalStorage<string | null>(PHONE_STORAGE_KEY, null);
 
   // Automatic token refresh - refreshes token before expiry, on focus, and on network reconnect
   useTokenRefresh({
@@ -350,35 +349,43 @@ const AuthProviderInternal: React.FC<AuthProviderProps> = ({ children, config })
     }
   }, [loadCurrentProfile, clearAuthState, pushToDefaultCallbackUrl, pushToDefaultAuthCallbackUrl, handleGlobalAuthError]);
 
-  // OTP methods - supports both email and phone - now uses AccountsContext
+  // OTP methods - email only - now uses AccountsContext
   const requestOTP = useCallback(
-    async (identifier: string, channel?: 'email' | 'phone', sourceUrl?: string): Promise<{ success: boolean; message: string }> => {
+    async (identifier: string, sourceUrl?: string): Promise<{ success: boolean; message: string; statusCode?: number; retryAfter?: number }> => {
       // Clear tokens before requesting OTP
       apiAccounts.clearTokens();
 
       try {
-        const channelValue = channel === 'phone' 
-          ? Enums.OTPRequestRequestChannel.PHONE 
-          : Enums.OTPRequestRequestChannel.EMAIL;
         const result = await accounts.requestOTP({
           identifier,
-          channel: channelValue,
+          source_url: sourceUrl,
         });
 
-        const channelName = channel === 'phone' ? 'phone number' : 'email address';
-
         // Track OTP request
         Analytics.event(AnalyticsEvent.AUTH_OTP_REQUEST, {
           category: AnalyticsCategory.AUTH,
-          label: channel || 'email',
+          label: 'email',
         });
 
         return {
           success: true,
-          message: result.message || `OTP code sent to your ${channelName}`,
+          message: result.message || `OTP code sent to your email address`,
         };
       } catch (error) {
         authLogger.error('Request OTP error:', error);
+
+        if (error instanceof APIError) {
+          const retryAfter = error.response?.retry_after ?? error.response?.retryAfter;
+          // Django returns { error, error_code, retry_after } — errorMessage reads 'detail'/'message' only
+          const message = error.response?.error || error.response?.detail || error.response?.message || error.errorMessage;
+          return {
+            success: false,
+            statusCode: error.statusCode,
+            message,
+            retryAfter: typeof retryAfter === 'number' ? retryAfter : undefined,
+          };
+        }
+
         return {
           success: false,
           message: 'Failed to send OTP',
@@ -389,7 +396,7 @@ const AuthProviderInternal: React.FC<AuthProviderProps> = ({ children, config })
   );
 
   const verifyOTP = useCallback(
-    async (identifier: string, otpCode: string, channel?: 'email' | 'phone', sourceUrl?: string, redirectUrl?: string, skipRedirect?: boolean): Promise<{
+    async (identifier: string, otpCode: string, sourceUrl?: string, redirectUrl?: string, skipRedirect?: boolean): Promise<{
       success: boolean;
       message: string;
       user?: UserProfile;
@@ -398,14 +405,11 @@ const AuthProviderInternal: React.FC<AuthProviderProps> = ({ children, config })
       should_prompt_2fa?: boolean;
     }> => {
       try {
-        const channelValue = channel === 'phone'
-          ? Enums.OTPRequestRequestChannel.PHONE
-          : Enums.OTPRequestRequestChannel.EMAIL;
         // AccountsContext automatically saves tokens and refreshes profile
         const result = await accounts.verifyOTP({
           identifier,
           otp: otpCode,
-          channel: channelValue,
+          source_url: sourceUrl,
         });
 
         // Check if 2FA is required - return early with session info
@@ -429,13 +433,9 @@ const AuthProviderInternal: React.FC<AuthProviderProps> = ({ children, config })
           };
         }
 
-        // Save identifier based on channel and clear opposite channel
-        if (channel === 'phone') {
-          setStoredPhone(identifier);
-          clearStoredEmail();
-        } else if (identifier.includes('@')) {
+        // Save email identifier
+        if (identifier.includes('@')) {
           setStoredEmail(identifier);
-          clearStoredPhone();
         }
 
         // Small delay to ensure profile state is updated
@@ -444,7 +444,7 @@ const AuthProviderInternal: React.FC<AuthProviderProps> = ({ children, config })
         // Track successful login
         Analytics.event(AnalyticsEvent.AUTH_LOGIN_SUCCESS, {
           category: AnalyticsCategory.AUTH,
-          label: channel || 'email',
+          label: 'email',
         });
 
         // Set user ID for future tracking
@@ -474,16 +474,20 @@ const AuthProviderInternal: React.FC<AuthProviderProps> = ({ children, config })
         // Track failed verification
         Analytics.event(AnalyticsEvent.AUTH_OTP_VERIFY_FAIL, {
           category: AnalyticsCategory.AUTH,
-          label: channel || 'email',
+          label: 'email',
         });
 
+        if (error instanceof APIError) {
+          const message = error.response?.error || error.response?.detail || error.response?.message || error.errorMessage;
+          return { success: false, message };
+        }
         return {
           success: false,
           message: 'Failed to verify OTP',
         };
       }
     },
-    [setStoredEmail, setStoredPhone, clearStoredEmail, clearStoredPhone, config?.routes?.defaultCallback, accounts, router],
+    [setStoredEmail, config?.routes?.defaultCallback, accounts, router],
   );
 
   const refreshToken = useCallback(async (): Promise<{ success: boolean; message: string }> => {
@@ -584,9 +588,6 @@ const AuthProviderInternal: React.FC<AuthProviderProps> = ({ children, config })
       getSavedEmail: () => storedEmail,
       saveEmail: setStoredEmail,
       clearSavedEmail: clearStoredEmail,
-      getSavedPhone: () => storedPhone,
-      savePhone: setStoredPhone,
-      clearSavedPhone: clearStoredPhone,
       requestOTP,
       verifyOTP,
       refreshToken,
@@ -609,9 +610,6 @@ const AuthProviderInternal: React.FC<AuthProviderProps> = ({ children, config })
       storedEmail,
       setStoredEmail,
       clearStoredEmail,
-      storedPhone,
-      setStoredPhone,
-      clearStoredPhone,
       requestOTP,
       verifyOTP,
       refreshToken,
@@ -662,11 +660,6 @@ const defaultAuthState: AuthContextType = {
     authLogger.warn('useAuth: saveEmail called outside AuthProvider');
   },
   clearSavedEmail: () => {},
-  getSavedPhone: () => null,
-  savePhone: () => {
-    authLogger.warn('useAuth: savePhone called outside AuthProvider');
-  },
-  clearSavedPhone: () => {},
   requestOTP: async () => {
     authLogger.warn('useAuth: requestOTP called outside AuthProvider');
     return { success: false, message: 'AuthProvider not available' };

package/src/auth/context/types.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 
 import type { User } from '../../';
+import type { OTPRequestResult } from '../types';
 
 // User profile type
 export type UserProfile = User;
@@ -34,14 +35,9 @@ export interface AuthContextType {
   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, redirectUrl?: string, skipRedirect?: boolean) => Promise<{
+  // OTP Methods - email only
+  requestOTP: (identifier: string, sourceUrl?: string) => Promise<OTPRequestResult>;
+  verifyOTP: (identifier: string, otpCode: string, sourceUrl?: string, redirectUrl?: string, skipRedirect?: boolean) => Promise<{
     success: boolean;
     message: string;
     user?: UserProfile;
@@ -67,4 +63,4 @@ export interface AuthContextType {
 export interface AuthProviderProps {
   children: React.ReactNode;
   config?: AuthConfig;
-} 
+}

package/src/auth/hooks/index.ts

@@ -6,7 +6,7 @@ export { useQueryParams } from './useQueryParams';
 
 // Core form hooks (decomposed)
 export { useAuthFormState, type UseAuthFormStateReturn } from './useAuthFormState';
-export { useAuthValidation, detectChannelFromIdentifier, validateIdentifier } from './useAuthValidation';
+export { useAuthValidation, validateIdentifier } from './useAuthValidation';
 
 // Complete form hook (composes the above)
 export { useAuthForm, type AuthFormReturn, type UseAuthFormOptions } from './useAuthForm';

package/src/auth/hooks/useAuthForm.ts

@@ -9,7 +9,7 @@ import { useAuthValidation } from './useAuthValidation';
 import { useAutoAuth } from './useAutoAuth';
 import { useTwoFactor } from './useTwoFactor';
 
-import type { AuthChannel, AuthFormReturn, UseAuthFormOptions } from '../types';
+import type { AuthFormReturn, UseAuthFormOptions } from '../types';
 /**
  * Complete auth form hook.
  * Composes smaller hooks for state, validation, and submission.
@@ -39,16 +39,11 @@ export const useAuthForm = (options: UseAuthFormOptions): AuthFormReturn => {
     verifyOTP,
     getSavedEmail,
     saveEmail,
-    clearSavedEmail,
-    getSavedPhone,
-    savePhone,
-    clearSavedPhone,
   } = useAuth();
 
   // Destructure for convenience
   const {
     identifier,
-    channel,
     otp,
     isLoading,
     acceptedTerms,
@@ -56,7 +51,6 @@ export const useAuthForm = (options: UseAuthFormOptions): AuthFormReturn => {
     twoFactorCode,
     useBackupCode,
     setIdentifier,
-    setChannel,
     setOtp,
     setStep,
     setError,
@@ -66,6 +60,7 @@ export const useAuthForm = (options: UseAuthFormOptions): AuthFormReturn => {
     setShouldPrompt2FA,
     setTwoFactorCode,
     setUseBackupCode,
+    startRateLimitCountdown,
   } = formState;
 
   // 2FA verification hook - skip redirect so we can show success screen
@@ -83,21 +78,15 @@ export const useAuthForm = (options: UseAuthFormOptions): AuthFormReturn => {
     skipRedirect: true, // We handle navigation via success step
   });
 
-  const { detectChannelFromIdentifier, validateIdentifier } = validation;
+  const { validateIdentifier } = validation;
 
   // ─────────────────────────────────────────────────────────────────────────
   // Storage Helper
   // ─────────────────────────────────────────────────────────────────────────
 
-  const saveIdentifierToStorage = useCallback((id: string, ch: AuthChannel) => {
-    if (ch === 'email') {
-      saveEmail(id);
-      clearSavedPhone();
-    } else {
-      savePhone(id);
-      clearSavedEmail();
-    }
-  }, [saveEmail, savePhone, clearSavedEmail, clearSavedPhone]);
+  const saveIdentifierToStorage = useCallback((id: string) => {
+    saveEmail(id);
+  }, [saveEmail]);
 
   // ─────────────────────────────────────────────────────────────────────────
   // Effects
@@ -105,28 +94,12 @@ export const useAuthForm = (options: UseAuthFormOptions): AuthFormReturn => {
 
   // Load saved identifier on mount
   useEffect(() => {
-    const savedPhone = getSavedPhone();
     const savedEmail = getSavedEmail();
-
-    // Prioritize phone over email
-    if (savedPhone) {
-      setIdentifier(savedPhone);
-      setChannel('phone');
-    } else if (savedEmail) {
+    if (savedEmail) {
       setIdentifier(savedEmail);
-      setChannel('email');
     }
-  }, [getSavedEmail, getSavedPhone, setIdentifier, setChannel]);
-
-  // Auto-detect channel when identifier changes
-  useEffect(() => {
-    if (identifier) {
-      const detected = detectChannelFromIdentifier(identifier);
-      if (detected && detected !== channel) {
-        setChannel(detected);
-      }
-    }
-  }, [identifier, channel, detectChannelFromIdentifier, setChannel]);
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
 
   // ─────────────────────────────────────────────────────────────────────────
   // Submit Handlers
@@ -136,18 +109,14 @@ export const useAuthForm = (options: UseAuthFormOptions): AuthFormReturn => {
     e.preventDefault();
 
     if (!identifier) {
-      const msg = channel === 'phone'
-        ? 'Please enter your phone number'
-        : 'Please enter your email address';
+      const msg = 'Please enter your email address';
       setError(msg);
       onError?.(msg);
       return;
     }
 
-    if (!validateIdentifier(identifier, channel)) {
-      const msg = channel === 'phone'
-        ? 'Please enter a valid phone number (e.g., +1234567890)'
-        : 'Please enter a valid email address';
+    if (!validateIdentifier(identifier)) {
+      const msg = 'Please enter a valid email address';
       setError(msg);
       onError?.(msg);
       return;
@@ -164,15 +133,20 @@ export const useAuthForm = (options: UseAuthFormOptions): AuthFormReturn => {
     clearError();
 
     try {
-      const result = await requestOTP(identifier, channel, sourceUrl);
+      const result = await requestOTP(identifier, sourceUrl);
 
       if (result.success) {
-        saveIdentifierToStorage(identifier, channel);
+        saveIdentifierToStorage(identifier);
         setStep('otp');
-        onIdentifierSuccess?.(identifier, channel);
+        onIdentifierSuccess?.(identifier);
       } else {
-        setError(result.message);
-        onError?.(result.message);
+        if (result.retryAfter) {
+          startRateLimitCountdown(result.retryAfter);
+          clearError();
+        } else {
+          setError(result.message);
+          onError?.(result.message);
+        }
       }
     } catch {
       const msg = 'An unexpected error occurred';
@@ -182,17 +156,16 @@ export const useAuthForm = (options: UseAuthFormOptions): AuthFormReturn => {
       setIsLoading(false);
     }
   }, [
-    identifier, channel, acceptedTerms, requireTermsAcceptance,
+    identifier, acceptedTerms, requireTermsAcceptance,
     validateIdentifier, requestOTP, saveIdentifierToStorage,
     setError, setIsLoading, setStep, clearError,
-    onIdentifierSuccess, onError, sourceUrl,
+    startRateLimitCountdown, onIdentifierSuccess, onError, sourceUrl,
   ]);
 
   // Core OTP submit - accepts explicit values to avoid stale closures
   const submitOTP = useCallback(async (
     submitIdentifier: string,
     submitOtp: string,
-    submitChannel: AuthChannel
   ): Promise<boolean> => {
     if (!submitOtp || submitOtp.length < 6) {
       const msg = 'Please enter the 6-digit verification code';
@@ -206,7 +179,7 @@ export const useAuthForm = (options: UseAuthFormOptions): AuthFormReturn => {
 
     try {
       // Skip redirect - we'll show success screen first
-      const result = await verifyOTP(submitIdentifier, submitOtp, submitChannel, sourceUrl, redirectUrl, true);
+      const result = await verifyOTP(submitIdentifier, submitOtp, sourceUrl, redirectUrl, true);
 
       // Check if 2FA is required (user has TOTP device)
       if (result.requires_2fa && result.session_id) {
@@ -214,12 +187,12 @@ export const useAuthForm = (options: UseAuthFormOptions): AuthFormReturn => {
         setTwoFactorSessionId(result.session_id);
         setShouldPrompt2FA(result.should_prompt_2fa || false);
         setStep('2fa');
-        saveIdentifierToStorage(submitIdentifier, submitChannel);
+        saveIdentifierToStorage(submitIdentifier);
         return true; // OTP was successful, now need 2FA
       }
 
       if (result.success) {
-        saveIdentifierToStorage(submitIdentifier, submitChannel);
+        saveIdentifierToStorage(submitIdentifier);
 
         // Check if user should be prompted to set up 2FA
         // Only show 2FA setup prompt if enable2FASetup is true (default)
@@ -257,22 +230,27 @@ export const useAuthForm = (options: UseAuthFormOptions): AuthFormReturn => {
 
   const handleOTPSubmit = useCallback(async (e: React.FormEvent) => {
     e.preventDefault();
-    await submitOTP(identifier, otp, channel);
-  }, [identifier, otp, channel, submitOTP]);
+    await submitOTP(identifier, otp);
+  }, [identifier, otp, submitOTP]);
 
   const handleResendOTP = useCallback(async () => {
     setIsLoading(true);
     clearError();
 
     try {
-      const result = await requestOTP(identifier, channel, sourceUrl);
+      const result = await requestOTP(identifier, sourceUrl);
 
       if (result.success) {
-        saveIdentifierToStorage(identifier, channel);
+        saveIdentifierToStorage(identifier);
         setOtp('');
       } else {
-        setError(result.message);
-        onError?.(result.message);
+        if (result.retryAfter) {
+          startRateLimitCountdown(result.retryAfter);
+          clearError(); // countdown in rateLimitLabel is enough feedback
+        } else {
+          setError(result.message);
+          onError?.(result.message);
+        }
       }
     } catch {
       const msg = 'Failed to resend verification code';
@@ -281,7 +259,7 @@ export const useAuthForm = (options: UseAuthFormOptions): AuthFormReturn => {
     } finally {
       setIsLoading(false);
     }
-  }, [identifier, channel, requestOTP, saveIdentifierToStorage, setOtp, setError, setIsLoading, clearError, onError, sourceUrl]);
+  }, [identifier, requestOTP, saveIdentifierToStorage, setOtp, setError, setIsLoading, clearError, startRateLimitCountdown, onError, sourceUrl]);
 
   const handleBackToIdentifier = useCallback(() => {
     setStep('identifier');
@@ -338,19 +316,8 @@ export const useAuthForm = (options: UseAuthFormOptions): AuthFormReturn => {
 
       authLogger.info('OTP detected from URL, auto-submitting');
 
-      const savedPhone = getSavedPhone();
       const savedEmail = getSavedEmail();
-
-      let autoIdentifier = '';
-      let autoChannel: AuthChannel = 'email';
-
-      if (savedPhone) {
-        autoIdentifier = savedPhone;
-        autoChannel = 'phone';
-      } else if (savedEmail) {
-        autoIdentifier = savedEmail;
-        autoChannel = 'email';
-      }
+      const autoIdentifier = savedEmail || '';
 
       if (!autoIdentifier) {
         authLogger.warn('No saved identifier found for auto-submit');
@@ -360,14 +327,13 @@ export const useAuthForm = (options: UseAuthFormOptions): AuthFormReturn => {
 
       // Update UI state
       setIdentifier(autoIdentifier);
-      setChannel(autoChannel);
       setOtp(detectedOtp);
       setStep('otp');
 
       // Submit with explicit values
       setTimeout(async () => {
         try {
-          await submitOTP(autoIdentifier, detectedOtp, autoChannel);
+          await submitOTP(autoIdentifier, detectedOtp);
         } finally {
           isAutoSubmitFromUrlRef.current = false;
         }
@@ -405,6 +371,7 @@ export const useAuthForm = (options: UseAuthFormOptions): AuthFormReturn => {
     // 2FA state from hook (for loading indicator)
     is2FALoading: twoFactor.isLoading,
     twoFactorWarning: twoFactor.warning,
+    twoFactorAttemptsRemaining: twoFactor.attemptsRemaining,
   };
 };
 

package/src/auth/hooks/useAuthFormState.ts

@@ -1,8 +1,14 @@
 "use client"
 
-import { useCallback, useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
 
-import type { AuthChannel, AuthFormState, AuthFormStateHandlers, AuthStep } from '../types';
+import type { AuthFormState, AuthFormStateHandlers, AuthStep } from '../types';
+
+const formatCountdown = (s: number): string => {
+  if (s <= 0) return '';
+  const m = Math.floor(s / 60);
+  return m > 0 ? `${m}:${String(s % 60).padStart(2, '0')}` : `${s}s`;
+};
 
 export interface UseAuthFormStateReturn extends AuthFormState, AuthFormStateHandlers {}
 
@@ -12,10 +18,8 @@ export interface UseAuthFormStateReturn extends AuthFormState, AuthFormStateHand
  */
 export const useAuthFormState = (
   initialIdentifier = '',
-  initialChannel: AuthChannel = 'email'
 ): UseAuthFormStateReturn => {
   const [identifier, setIdentifier] = useState(initialIdentifier);
-  const [channel, setChannel] = useState<AuthChannel>(initialChannel);
   const [otp, setOtp] = useState('');
   const [isLoading, setIsLoading] = useState(false);
   const [acceptedTerms, setAcceptedTerms] = useState(true);
@@ -28,12 +32,34 @@ export const useAuthFormState = (
   const [twoFactorCode, setTwoFactorCode] = useState('');
   const [useBackupCode, setUseBackupCode] = useState(false);
 
+  // Rate limit countdown
+  const [rateLimitSeconds, setRateLimitSeconds] = useState(0);
+  const rateLimitTimerRef = useRef<ReturnType<typeof setInterval> | null>(null);
+
+  const startRateLimitCountdown = useCallback((seconds: number) => {
+    if (rateLimitTimerRef.current) clearInterval(rateLimitTimerRef.current);
+    setRateLimitSeconds(seconds);
+    rateLimitTimerRef.current = setInterval(() => {
+      setRateLimitSeconds((prev) => {
+        if (prev <= 1) {
+          clearInterval(rateLimitTimerRef.current!);
+          rateLimitTimerRef.current = null;
+          return 0;
+        }
+        return prev - 1;
+      });
+    }, 1000);
+  }, []);
+
+  useEffect(() => () => {
+    if (rateLimitTimerRef.current) clearInterval(rateLimitTimerRef.current);
+  }, []);
+
   const clearError = useCallback(() => setError(''), []);
 
   return {
     // State
     identifier,
-    channel,
     otp,
     isLoading,
     acceptedTerms,
@@ -43,9 +69,11 @@ export const useAuthFormState = (
     shouldPrompt2FA,
     twoFactorCode,
     useBackupCode,
+    rateLimitSeconds,
+    isRateLimited: rateLimitSeconds > 0,
+    rateLimitLabel: formatCountdown(rateLimitSeconds),
     // Handlers
     setIdentifier,
-    setChannel,
     setOtp,
     setAcceptedTerms,
     setError,
@@ -56,5 +84,6 @@ export const useAuthFormState = (
     setShouldPrompt2FA,
     setTwoFactorCode,
     setUseBackupCode,
+    startRateLimitCountdown,
   };
 };

package/src/auth/hooks/useAuthValidation.ts

@@ -2,76 +2,16 @@
 
 import { useCallback } from 'react';
 
-import type { AuthChannel, AuthFormValidation } from '../types';
+import type { AuthFormValidation } from '../types';
 
-// Email regex - RFC 5322 simplified
 const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 
-// Phone regex - E.164 format (+[country][number], 7-15 digits)
-const PHONE_REGEX = /^\+[1-9]\d{6,14}$/;
-
-/**
- * Hook for auth identifier validation.
- * Pure functions - no state, no side effects.
- */
 export const useAuthValidation = (): AuthFormValidation => {
-  /**
-   * Detect channel type from identifier string.
-   * Returns 'email' if contains @, 'phone' if starts with + and matches E.164.
-   */
-  const detectChannelFromIdentifier = useCallback((id: string): AuthChannel | null => {
-    if (!id) return null;
-
-    // Email detection - contains @
-    if (id.includes('@')) {
-      return 'email';
-    }
-
-    // Phone detection - starts with + and matches E.164 format
-    if (id.startsWith('+') && PHONE_REGEX.test(id)) {
-      return 'phone';
-    }
-
-    return null;
+  const validateIdentifier = useCallback((id: string): boolean => {
+    return EMAIL_REGEX.test(id);
   }, []);
 
-  /**
-   * Validate identifier format based on channel type.
-   */
-  const validateIdentifier = useCallback((id: string, channelType?: AuthChannel): boolean => {
-    if (!id) return false;
-
-    const channel = channelType || detectChannelFromIdentifier(id);
-
-    if (channel === 'email') {
-      return EMAIL_REGEX.test(id);
-    }
-
-    if (channel === 'phone') {
-      return PHONE_REGEX.test(id);
-    }
-
-    return false;
-  }, [detectChannelFromIdentifier]);
-
-  return {
-    detectChannelFromIdentifier,
-    validateIdentifier,
-  };
+  return { validateIdentifier };
 };
 
-// Export standalone functions for use outside React
-export const detectChannelFromIdentifier = (id: string): AuthChannel | null => {
-  if (!id) return null;
-  if (id.includes('@')) return 'email';
-  if (id.startsWith('+') && PHONE_REGEX.test(id)) return 'phone';
-  return null;
-};
-
-export const validateIdentifier = (id: string, channelType?: AuthChannel): boolean => {
-  if (!id) return false;
-  const channel = channelType || detectChannelFromIdentifier(id);
-  if (channel === 'email') return EMAIL_REGEX.test(id);
-  if (channel === 'phone') return PHONE_REGEX.test(id);
-  return false;
-};
+export const validateIdentifier = (id: string): boolean => EMAIL_REGEX.test(id);