@payez/next-mvp 4.1.9 → 4.1.10

package/src/hooks/usePasswordValidation.ts

@@ -1,127 +1,127 @@
-/**
- * Password Validation Hook for @payez/next-mvp
- *
- * Provides real-time password validation against IDP password policy.
- * Uses debounced API calls to validate password strength.
- */
-
-'use client';
-
-import { useState, useCallback, useRef, useEffect } from 'react';
-
-interface PasswordPolicy {
-  min_length?: number;
-  require_uppercase?: boolean;
-  require_lowercase?: boolean;
-  require_digit?: boolean;
-  require_special?: boolean;
-  min_strength_score?: number;
-}
-
-interface ValidationResult {
-  is_valid: boolean;
-  score: number;
-  failed_requirements: string[];
-  tip?: string;
-  policy?: PasswordPolicy;
-}
-
-interface UsePasswordValidationOptions {
-  debounceMs?: number;
-}
-
-export function usePasswordValidation(options: UsePasswordValidationOptions = {}) {
-  const { debounceMs = 300 } = options;
-
-  const [isValid, setIsValid] = useState(false);
-  const [score, setScore] = useState(0);
-  const [failedRequirements, setFailedRequirements] = useState<string[]>([]);
-  const [tip, setTip] = useState<string | undefined>(undefined);
-  const [policy, setPolicy] = useState<PasswordPolicy | undefined>(undefined);
-  const [isValidating, setIsValidating] = useState(false);
-
-  const debounceTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-  const abortControllerRef = useRef<AbortController | null>(null);
-
-  const validatePassword = useCallback(async (password: string) => {
-    // Cancel any pending request
-    if (abortControllerRef.current) {
-      abortControllerRef.current.abort();
-    }
-
-    // Don't validate empty passwords
-    if (!password || password.length === 0) {
-      setIsValid(false);
-      setScore(0);
-      setFailedRequirements([]);
-      setTip(undefined);
-      return;
-    }
-
-    setIsValidating(true);
-    abortControllerRef.current = new AbortController();
-
-    try {
-      const response = await fetch('/api/account/validate-password', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ password }),
-        signal: abortControllerRef.current.signal,
-      });
-
-      const data: ValidationResult = await response.json();
-
-      setIsValid(data.is_valid);
-      setScore(data.score);
-      setFailedRequirements(data.failed_requirements || []);
-      setTip(data.tip);
-      if (data.policy) {
-        setPolicy(data.policy);
-      }
-    } catch (err: any) {
-      if (err.name !== 'AbortError') {
-        console.error('[usePasswordValidation] Error:', err);
-        // On error, assume invalid but don't block user
-        setIsValid(false);
-        setScore(0);
-        setFailedRequirements(['Unable to validate password']);
-      }
-    } finally {
-      setIsValidating(false);
-    }
-  }, []);
-
-  const setPassword = useCallback((password: string) => {
-    // Clear any pending debounce
-    if (debounceTimerRef.current) {
-      clearTimeout(debounceTimerRef.current);
-    }
-
-    // Debounce the validation
-    debounceTimerRef.current = setTimeout(() => {
-      validatePassword(password);
-    }, debounceMs);
-  }, [debounceMs, validatePassword]);
-
-  // Cleanup on unmount
-  useEffect(() => {
-    return () => {
-      if (debounceTimerRef.current) {
-        clearTimeout(debounceTimerRef.current);
-      }
-      if (abortControllerRef.current) {
-        abortControllerRef.current.abort();
-      }
-    };
-  }, []);
-
-  return {
-    setPassword,
-    isValid,
-    score,
-    failedRequirements,
-    tip,
-    policy,
-    isValidating,
-  };
-}
+/**
+ * Password Validation Hook for @payez/next-mvp
+ *
+ * Provides real-time password validation against IDP password policy.
+ * Uses debounced API calls to validate password strength.
+ */
+
+'use client';
+
+import { useState, useCallback, useRef, useEffect } from 'react';
+
+interface PasswordPolicy {
+  min_length?: number;
+  require_uppercase?: boolean;
+  require_lowercase?: boolean;
+  require_digit?: boolean;
+  require_special?: boolean;
+  min_strength_score?: number;
+}
+
+interface ValidationResult {
+  is_valid: boolean;
+  score: number;
+  failed_requirements: string[];
+  tip?: string;
+  policy?: PasswordPolicy;
+}
+
+interface UsePasswordValidationOptions {
+  debounceMs?: number;
+}
+
+export function usePasswordValidation(options: UsePasswordValidationOptions = {}) {
+  const { debounceMs = 300 } = options;
+
+  const [isValid, setIsValid] = useState(false);
+  const [score, setScore] = useState(0);
+  const [failedRequirements, setFailedRequirements] = useState<string[]>([]);
+  const [tip, setTip] = useState<string | undefined>(undefined);
+  const [policy, setPolicy] = useState<PasswordPolicy | undefined>(undefined);
+  const [isValidating, setIsValidating] = useState(false);
+
+  const debounceTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const abortControllerRef = useRef<AbortController | null>(null);
+
+  const validatePassword = useCallback(async (password: string) => {
+    // Cancel any pending request
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+
+    // Don't validate empty passwords
+    if (!password || password.length === 0) {
+      setIsValid(false);
+      setScore(0);
+      setFailedRequirements([]);
+      setTip(undefined);
+      return;
+    }
+
+    setIsValidating(true);
+    abortControllerRef.current = new AbortController();
+
+    try {
+      const response = await fetch('/api/account/validate-password', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ password }),
+        signal: abortControllerRef.current.signal,
+      });
+
+      const data: ValidationResult = await response.json();
+
+      setIsValid(data.is_valid);
+      setScore(data.score);
+      setFailedRequirements(data.failed_requirements || []);
+      setTip(data.tip);
+      if (data.policy) {
+        setPolicy(data.policy);
+      }
+    } catch (err: any) {
+      if (err.name !== 'AbortError') {
+        console.error('[usePasswordValidation] Error:', err);
+        // On error, assume invalid but don't block user
+        setIsValid(false);
+        setScore(0);
+        setFailedRequirements(['Unable to validate password']);
+      }
+    } finally {
+      setIsValidating(false);
+    }
+  }, []);
+
+  const setPassword = useCallback((password: string) => {
+    // Clear any pending debounce
+    if (debounceTimerRef.current) {
+      clearTimeout(debounceTimerRef.current);
+    }
+
+    // Debounce the validation
+    debounceTimerRef.current = setTimeout(() => {
+      validatePassword(password);
+    }, debounceMs);
+  }, [debounceMs, validatePassword]);
+
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      if (debounceTimerRef.current) {
+        clearTimeout(debounceTimerRef.current);
+      }
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+    };
+  }, []);
+
+  return {
+    setPassword,
+    isValid,
+    score,
+    failedRequirements,
+    tip,
+    policy,
+    isValidating,
+  };
+}

package/src/hooks/usePublicAuthSettings.ts

@@ -1,149 +1,149 @@
-/**
- * usePublicAuthSettings Hook
- *
- * Fetches public auth settings for pre-login pages (signup, login).
- * Does NOT require authentication - settings are fetched via API.
- */
-
-'use client';
-
-import { useState, useEffect } from 'react';
-import type { FederatedProvider } from '../types/auth';
-
-export interface PublicAuthSettings {
-    enabledProviders: FederatedProvider[];
-    allowPublicRegistration: boolean;
-    allowFederatedLogin: boolean;
-    enablePasswordReset: boolean;
-    require2FA: boolean;
-    allowed2FAMethods: string[];
-}
-
-export interface UsePublicAuthSettingsResult {
-    settings: PublicAuthSettings | null;
-    isLoading: boolean;
-    error: Error | null;
-}
-
-// Map provider strings to FederatedProvider type
-const PROVIDER_MAP: Record<string, FederatedProvider> = {
-    'google': 'google',
-    'apple': 'apple',
-    'facebook': 'facebook',
-    'github': 'github',
-    'microsoft': 'microsoft',
-    'azure-ad': 'microsoft',
-};
-
-const DEFAULT_SETTINGS: PublicAuthSettings = {
-    enabledProviders: [],
-    allowPublicRegistration: true,
-    allowFederatedLogin: false,
-    enablePasswordReset: true,
-    require2FA: true,
-    allowed2FAMethods: ['email', 'sms'],
-};
-
-/**
- * Hook to fetch public auth settings for login/signup pages.
- *
- * @example
- * ```tsx
- * function SignupPage() {
- *   const { settings, isLoading } = usePublicAuthSettings();
- *
- *   if (isLoading) return <Spinner />;
- *
- *   return (
- *     <>
- *       {settings?.allowFederatedLogin && (
- *         <FederatedAuthSection providers={settings.enabledProviders} />
- *       )}
- *       {settings?.allowPublicRegistration && (
- *         <EmailSignupForm />
- *       )}
- *     </>
- *   );
- * }
- * ```
- */
-export function usePublicAuthSettings(): UsePublicAuthSettingsResult {
-    const [settings, setSettings] = useState<PublicAuthSettings | null>(null);
-    const [isLoading, setIsLoading] = useState(true);
-    const [error, setError] = useState<Error | null>(null);
-
-    useEffect(() => {
-        let mounted = true;
-
-        async function fetchSettings() {
-            try {
-                const response = await fetch('/api/auth/settings');
-
-                if (!mounted) return;
-
-                if (!response.ok) {
-                    throw new Error(`Failed to fetch auth settings: ${response.status}`);
-                }
-
-                const data = await response.json();
-
-                if (data.success && data.data) {
-                    // Map provider strings to FederatedProvider type
-                    const providers = (data.data.enabledProviders || [])
-                        .map((p: string) => PROVIDER_MAP[p.toLowerCase()])
-                        .filter((p: FederatedProvider | undefined): p is FederatedProvider => p !== undefined);
-
-                    setSettings({
-                        ...data.data,
-                        enabledProviders: providers,
-                    });
-                } else {
-                    setSettings(DEFAULT_SETTINGS);
-                }
-
-                setError(null);
-            } catch (err) {
-                if (!mounted) return;
-                console.warn('[usePublicAuthSettings] Failed to fetch settings:', err);
-                setError(err instanceof Error ? err : new Error(String(err)));
-                setSettings(DEFAULT_SETTINGS);
-            } finally {
-                if (mounted) {
-                    setIsLoading(false);
-                }
-            }
-        }
-
-        fetchSettings();
-
-        return () => {
-            mounted = false;
-        };
-    }, []);
-
-    return { settings, isLoading, error };
-}
-
-/**
- * Hook to check if federated (OAuth) login is enabled.
- */
-export function useFederatedLoginEnabled(): boolean {
-    const { settings } = usePublicAuthSettings();
-    return settings?.allowFederatedLogin ?? false;
-}
-
-/**
- * Hook to check if public registration is enabled.
- */
-export function usePublicRegistrationEnabled(): boolean {
-    const { settings } = usePublicAuthSettings();
-    return settings?.allowPublicRegistration ?? true;
-}
-
-/**
- * Hook to check if password reset is enabled.
- */
-export function usePasswordResetEnabled(): boolean {
-    const { settings } = usePublicAuthSettings();
-    return settings?.enablePasswordReset ?? true;
-}
+/**
+ * usePublicAuthSettings Hook
+ *
+ * Fetches public auth settings for pre-login pages (signup, login).
+ * Does NOT require authentication - settings are fetched via API.
+ */
+
+'use client';
+
+import { useState, useEffect } from 'react';
+import type { FederatedProvider } from '../types/auth';
+
+export interface PublicAuthSettings {
+    enabledProviders: FederatedProvider[];
+    allowPublicRegistration: boolean;
+    allowFederatedLogin: boolean;
+    enablePasswordReset: boolean;
+    require2FA: boolean;
+    allowed2FAMethods: string[];
+}
+
+export interface UsePublicAuthSettingsResult {
+    settings: PublicAuthSettings | null;
+    isLoading: boolean;
+    error: Error | null;
+}
+
+// Map provider strings to FederatedProvider type
+const PROVIDER_MAP: Record<string, FederatedProvider> = {
+    'google': 'google',
+    'apple': 'apple',
+    'facebook': 'facebook',
+    'github': 'github',
+    'microsoft': 'microsoft',
+    'azure-ad': 'microsoft',
+};
+
+const DEFAULT_SETTINGS: PublicAuthSettings = {
+    enabledProviders: [],
+    allowPublicRegistration: true,
+    allowFederatedLogin: false,
+    enablePasswordReset: true,
+    require2FA: true,
+    allowed2FAMethods: ['email', 'sms'],
+};
+
+/**
+ * Hook to fetch public auth settings for login/signup pages.
+ *
+ * @example
+ * ```tsx
+ * function SignupPage() {
+ *   const { settings, isLoading } = usePublicAuthSettings();
+ *
+ *   if (isLoading) return <Spinner />;
+ *
+ *   return (
+ *     <>
+ *       {settings?.allowFederatedLogin && (
+ *         <FederatedAuthSection providers={settings.enabledProviders} />
+ *       )}
+ *       {settings?.allowPublicRegistration && (
+ *         <EmailSignupForm />
+ *       )}
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export function usePublicAuthSettings(): UsePublicAuthSettingsResult {
+    const [settings, setSettings] = useState<PublicAuthSettings | null>(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState<Error | null>(null);
+
+    useEffect(() => {
+        let mounted = true;
+
+        async function fetchSettings() {
+            try {
+                const response = await fetch('/api/auth/settings');
+
+                if (!mounted) return;
+
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch auth settings: ${response.status}`);
+                }
+
+                const data = await response.json();
+
+                if (data.success && data.data) {
+                    // Map provider strings to FederatedProvider type
+                    const providers = (data.data.enabledProviders || [])
+                        .map((p: string) => PROVIDER_MAP[p.toLowerCase()])
+                        .filter((p: FederatedProvider | undefined): p is FederatedProvider => p !== undefined);
+
+                    setSettings({
+                        ...data.data,
+                        enabledProviders: providers,
+                    });
+                } else {
+                    setSettings(DEFAULT_SETTINGS);
+                }
+
+                setError(null);
+            } catch (err) {
+                if (!mounted) return;
+                console.warn('[usePublicAuthSettings] Failed to fetch settings:', err);
+                setError(err instanceof Error ? err : new Error(String(err)));
+                setSettings(DEFAULT_SETTINGS);
+            } finally {
+                if (mounted) {
+                    setIsLoading(false);
+                }
+            }
+        }
+
+        fetchSettings();
+
+        return () => {
+            mounted = false;
+        };
+    }, []);
+
+    return { settings, isLoading, error };
+}
+
+/**
+ * Hook to check if federated (OAuth) login is enabled.
+ */
+export function useFederatedLoginEnabled(): boolean {
+    const { settings } = usePublicAuthSettings();
+    return settings?.allowFederatedLogin ?? false;
+}
+
+/**
+ * Hook to check if public registration is enabled.
+ */
+export function usePublicRegistrationEnabled(): boolean {
+    const { settings } = usePublicAuthSettings();
+    return settings?.allowPublicRegistration ?? true;
+}
+
+/**
+ * Hook to check if password reset is enabled.
+ */
+export function usePasswordResetEnabled(): boolean {
+    const { settings } = usePublicAuthSettings();
+    return settings?.enablePasswordReset ?? true;
+}