@umituz/react-native-auth 3.5.12 → 3.5.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "3.5.12",
+  "version": "3.5.13",
   "description": "Authentication service for React Native apps - Secure, type-safe, and production-ready. Provider-agnostic design with dependency injection, configurable validation, and comprehensive error handling.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/__tests__/utils/AuthPasswordValidation.test.ts

@@ -34,39 +34,8 @@ describe('AuthPasswordValidation', () => {
       expect(result.requirements.hasMinLength).toBe(false);
     });
 
-    it('should validate uppercase requirement', () => {
-      const configReq = { ...config, requireUppercase: true };
-      expect(validatePasswordForRegister('password', configReq).isValid).toBe(false);
-      expect(validatePasswordForRegister('Password', configReq).requirements.hasUppercase).toBe(true);
-    });
-
-    it('should validate lowercase requirement', () => {
-      const configReq = { ...config, requireLowercase: true };
-      expect(validatePasswordForRegister('PASSWORD', configReq).isValid).toBe(false);
-      expect(validatePasswordForRegister('Password', configReq).requirements.hasLowercase).toBe(true);
-    });
-
-    it('should validate number requirement', () => {
-      const configReq = { ...config, requireNumber: true };
-      expect(validatePasswordForRegister('Password', configReq).isValid).toBe(false);
-      expect(validatePasswordForRegister('Password1', configReq).requirements.hasNumber).toBe(true);
-    });
-
-    it('should validate special character requirement', () => {
-      const configReq = { ...config, requireSpecialChar: true };
-      expect(validatePasswordForRegister('Password1', configReq).isValid).toBe(false);
-      expect(validatePasswordForRegister('Password1!', configReq).requirements.hasSpecialChar).toBe(true);
-    });
-
-    it('should accept password that meets all requirements', () => {
-      const strictConfig = {
-        ...config,
-        requireUppercase: true,
-        requireLowercase: true,
-        requireNumber: true,
-        requireSpecialChar: true,
-      };
-      const result = validatePasswordForRegister('Password1!', strictConfig);
+    it('should accept password that meets length requirement', () => {
+      const result = validatePasswordForRegister('Password1!', config);
       expect(result.isValid).toBe(true);
     });
   });

package/src/infrastructure/utils/AuthValidation.ts

@@ -3,24 +3,16 @@ import type { PasswordConfig } from "../../domain/value-objects/AuthConfig";
 export interface ValidationResult { isValid: boolean; error?: string; }
 export interface PasswordStrengthResult extends ValidationResult { requirements: PasswordRequirements; }
 export interface PasswordRequirements {
-  hasMinLength: boolean; hasUppercase: boolean; hasLowercase: boolean; hasNumber: boolean; hasSpecialChar: boolean;
+  hasMinLength: boolean;
 }
 
 export interface ValidationConfig {
   emailRegex: RegExp;
-  uppercaseRegex: RegExp;
-  lowercaseRegex: RegExp;
-  numberRegex: RegExp;
-  specialCharRegex: RegExp;
   displayNameMinLength: number;
 }
 
 export const DEFAULT_VAL_CONFIG: ValidationConfig = {
   emailRegex: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
-  uppercaseRegex: /[A-Z]/,
-  lowercaseRegex: /[a-z]/,
-  numberRegex: /[0-9]/,
-  specialCharRegex: /[!@#$%^&*(),.?":{}|<>]/,
   displayNameMinLength: 2,
 };
 
@@ -41,28 +33,15 @@ export function validatePasswordForLogin(password: string): ValidationResult {
 export function validatePasswordForRegister(
   password: string,
   config: PasswordConfig,
-  validationConfig: ValidationConfig = DEFAULT_VAL_CONFIG
+  _validationConfig: ValidationConfig = DEFAULT_VAL_CONFIG
 ): PasswordStrengthResult {
-  /*
-   * Check for strict presence of characters regardless of configuration
-   * This ensures the UI reflects actual password content
-   */
   const req: PasswordRequirements = {
     hasMinLength: password.length >= config.minLength,
-    hasUppercase: validationConfig.uppercaseRegex.test(password),
-    hasLowercase: validationConfig.lowercaseRegex.test(password),
-    hasNumber: validationConfig.numberRegex.test(password),
-    hasSpecialChar: validationConfig.specialCharRegex.test(password),
   };
 
   if (!password) return { isValid: false, error: "auth.validation.passwordRequired", requirements: req };
   
-  // Validation checks based on configuration
   if (!req.hasMinLength) return { isValid: false, error: "auth.validation.passwordTooShort", requirements: req };
-  if (config.requireUppercase && !req.hasUppercase) return { isValid: false, error: "auth.validation.passwordRequireUppercase", requirements: req };
-  if (config.requireLowercase && !req.hasLowercase) return { isValid: false, error: "auth.validation.passwordRequireLowercase", requirements: req };
-  if (config.requireNumber && !req.hasNumber) return { isValid: false, error: "auth.validation.passwordRequireNumber", requirements: req };
-  if (config.requireSpecialChar && !req.hasSpecialChar) return { isValid: false, error: "auth.validation.passwordRequireSpecialChar", requirements: req };
 
   return { isValid: true, requirements: req };
 }

package/src/presentation/components/PasswordStrengthIndicator.tsx

@@ -51,10 +51,6 @@ export const PasswordStrengthIndicator: React.FC<
 
   const items = [
     { key: "minLength", label: t("auth.passwordReq.minLength"), isValid: requirements.hasMinLength },
-    { key: "uppercase", label: t("auth.passwordReq.uppercase"), isValid: requirements.hasUppercase },
-    { key: "lowercase", label: t("auth.passwordReq.lowercase"), isValid: requirements.hasLowercase },
-    { key: "number", label: t("auth.passwordReq.number"), isValid: requirements.hasNumber },
-    { key: "special", label: t("auth.passwordReq.special"), isValid: requirements.hasSpecialChar },
   ];
 
   if (!showLabels) {

package/src/presentation/hooks/useRegisterForm.ts

@@ -62,10 +62,6 @@ export function useRegisterForm(): UseRegisterFormResult {
     if (!password) {
       return {
         hasMinLength: false,
-        hasUppercase: false,
-        hasLowercase: false,
-        hasNumber: false,
-        hasSpecialChar: false,
       };
     }
     const result = validatePasswordForRegister(password, DEFAULT_PASSWORD_CONFIG);