validatePassword function

String? validatePassword(String? value, { int minLength = 8, Set<PasswordRequirement> requirements = const {PasswordRequirement.minLength}, String specialCharacters = r'[#?!@$%^&*-]', })

Validates a password string based on specified requirements and minLength.

By default, only the minimum length requirement (8 characters) is enforced.

Parameters:

• value: The password string to validate.
• minLength: Minimum required length of the password (default is 8).
• requirements: A set of PasswordRequirement enum values specifying which rules to enforce. Defaults to {PasswordRequirement.minLength}.
• specialCharacters: A string of allowed special characters for the special character requirement (default: r'[#?!@$%^&*-]').

Returns:

• null if the password satisfies all requirements.
• A string error message describing the first unmet requirement.

Usage examples:

Basic usage with default min length:

String? result1 = validatePassword('password123');

Require uppercase and special character:

String? result2 = validatePassword(
  'password123',
  requirements: {
    PasswordRequirement.minLength,
    PasswordRequirement.upperCase,
    PasswordRequirement.special,
  },
);

Custom min length and require digit:

String? result3 = validatePassword(
  'pass123',
  minLength: 6,
  requirements: {
    PasswordRequirement.minLength,
    PasswordRequirement.digit,
  },
);

All requirements with custom special characters:

String? result4 = validatePassword(
  'Password123!',
  requirements: PasswordRequirement.values.toSet(),
  specialCharacters: '!@#$%^&*',
);

Implementation

String? validatePassword(
  String? value, {
  int minLength = 8,
  Set<PasswordRequirement> requirements = const {PasswordRequirement.minLength},
  String specialCharacters = r'[#?!@$%^&*-]',
}) {
  final rules = <ValidationRule>[
    Validators.required(message: 'Password is required'),
  ];

  if (requirements.contains(PasswordRequirement.minLength)) {
    rules.add(
      Validators.minLength(
        minLength,
        message: 'Password must be at least $minLength characters long',
      ),
    );
  }

  if (requirements.contains(PasswordRequirement.upperCase)) {
    rules.add(
      Validators.pattern(
        r'(?=.*[A-Z])',
        message: 'Password must have at least one uppercase character',
      ),
    );
  }

  if (requirements.contains(PasswordRequirement.lowerCase)) {
    rules.add(
      Validators.pattern(
        r'(?=.*[a-z])',
        message: 'Password must have at least one lowercase character',
      ),
    );
  }

  if (requirements.contains(PasswordRequirement.digit)) {
    rules.add(
      Validators.pattern(
        r'(?=.*\d)',
        message: 'Password must have at least one digit',
      ),
    );
  }

  if (requirements.contains(PasswordRequirement.special)) {
    final escapedSpecialChars = RegExp.escape(specialCharacters);
    rules.add(
      Validators.pattern(
        '(?=.*[$escapedSpecialChars])',
        message:
            'Password must have at least one special character ($specialCharacters)',
      ),
    );
  }

  return Validators.validate(value, rules);
}