@umituz/react-native-auth 4.3.77 → 4.3.78

package/src/shared/form/types/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Form Types Public API
+ */
+
+export type {
+  FieldState,
+  FormState,
+  FieldChangeHandler,
+  FormFieldConfig,
+  FormConfig,
+} from './FormTypes';

package/src/shared/form/utils/fieldUtils.ts

@@ -0,0 +1,115 @@
+/**
+ * Field Utilities
+ * Utility functions for individual field operations
+ */
+
+/**
+ * Create field change handler with callback
+ */
+export function createFieldChangeHandler(
+  onChange: (value: string) => void,
+  callbacks?: {
+    onErrorClear?: () => void;
+    onValidationError?: () => void;
+  }
+) {
+  return (value: string) => {
+    onChange(value);
+    callbacks?.onErrorClear?.();
+  };
+}
+
+/**
+ * Create field blur handler
+ */
+export function createFieldBlurHandler(
+  onBlur: () => void,
+  validate?: () => void
+) {
+  return () => {
+    onBlur();
+    validate?.();
+  };
+}
+
+/**
+ * Debounce field change
+ */
+export function debounceFieldChange(
+  onChange: (value: string) => void,
+  delay: number = 300
+) {
+  let timeoutId: NodeJS.Timeout | null = null;
+
+  return (value: string) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+
+    timeoutId = setTimeout(() => {
+      onChange(value);
+    }, delay);
+  };
+}
+
+/**
+ * Check if field value is empty
+ */
+export function isFieldValueEmpty(value: string): boolean {
+  return !value || value.trim().length === 0;
+}
+
+/**
+ * Sanitize field value
+ */
+export function sanitizeFieldValue(
+  value: string,
+  sanitizers: Array<(value: string) => string>
+): string {
+  return sanitizers.reduce((acc, sanitizer) => sanitizer(acc), value);
+}
+
+/**
+ * Format field value for display
+ */
+export function formatFieldValue(
+  value: string,
+  formatter: (value: string) => string
+): string {
+  return formatter(value);
+}
+
+/**
+ * Validate field value
+ */
+export function validateFieldValue(
+  value: string,
+  validators: Array<(value: string) => boolean>
+): boolean {
+  return validators.every((validator) => validator(value));
+}
+
+/**
+ * Get field display value
+ */
+export function getFieldDisplayValue(
+  value: string,
+  placeholder: string = ''
+): string {
+  return value || placeholder;
+}
+
+/**
+ * Truncate field value
+ */
+export function truncateFieldValue(
+  value: string,
+  maxLength: number,
+  suffix: string = '...'
+): string {
+  if (value.length <= maxLength) {
+    return value;
+  }
+
+  return value.substring(0, maxLength - suffix.length) + suffix;
+}

package/src/shared/form/utils/formUtils.ts

@@ -0,0 +1,113 @@
+/**
+ * Form Utilities
+ * Utility functions for common form operations
+ */
+
+/**
+ * Sanitize form values
+ */
+export function sanitizeFormValues<T extends Record<string, string>>(
+  values: T,
+  sanitizers: Partial<Record<keyof T, (value: string) => string>>
+): T {
+  const sanitized = { ...values };
+
+  for (const key in sanitizers) {
+    if (key in sanitized) {
+      const sanitizer = sanitizers[key];
+      if (sanitizer) {
+        sanitized[key] = sanitizer(sanitized[key]);
+      }
+    }
+  }
+
+  return sanitized;
+}
+
+/**
+ * Extract form values for specific fields
+ */
+export function extractFields<T extends Record<string, string>>(
+  values: T,
+  fields: (keyof T)[]
+): Pick<T, keyof T> {
+  const extracted = {} as Pick<T, keyof T>;
+
+  for (const field of fields) {
+    if (field in values) {
+      extracted[field] = values[field];
+    }
+  }
+
+  return extracted;
+}
+
+/**
+ * Check if all required fields are filled
+ */
+export function areRequiredFieldsFilled<T extends Record<string, string>>(
+  values: T,
+  requiredFields: (keyof T)[]
+): boolean {
+  return requiredFields.every((field) => {
+    const value = values[field];
+    return value && value.trim().length > 0;
+  });
+}
+
+/**
+ * Get empty required fields
+ */
+export function getEmptyRequiredFields<T extends Record<string, string>>(
+  values: T,
+  requiredFields: (keyof T)[]
+): (keyof T)[] {
+  return requiredFields.filter((field) => {
+    const value = values[field];
+    return !value || value.trim().length === 0;
+  });
+}
+
+/**
+ * Create form field options
+ */
+export function createFieldOptions<T extends Record<string, string>>(
+  fields: Record<keyof T, { validateOnChange?: boolean; clearErrorOnChange?: boolean }>
+) {
+  return fields;
+}
+
+/**
+ * Merge form errors
+ */
+export function mergeFormErrors<T extends Record<string, string>>(
+  ...errorObjects: Array<Partial<Record<keyof T, string | null>>>
+): Record<keyof T, string | null> {
+  const merged = {} as Record<keyof T, string | null>;
+
+  for (const errors of errorObjects) {
+    for (const key in errors) {
+      if (errors[key as keyof T] !== undefined) {
+        merged[key as keyof T] = errors[key as keyof T] as string | null;
+      }
+    }
+  }
+
+  return merged;
+}
+
+/**
+ * Clear specific field errors
+ */
+export function clearFieldErrors<T extends Record<string, string>>(
+  errors: Record<keyof T, string | null>,
+  fields: (keyof T)[]
+): Record<keyof T, string | null> {
+  const cleared = { ...errors };
+
+  for (const field of fields) {
+    cleared[field] = null;
+  }
+
+  return cleared;
+}

package/src/shared/form/utils/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Form Utils Public API
+ */
+
+export * from './formUtils';
+export * from './fieldUtils';

package/src/shared/validation/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Validation Module Public API
+ * Centralized validation system
+ */
+
+// Types
+export type {
+  ValidationResult,
+  PasswordRequirements,
+  PasswordStrengthResult,
+  ValidationRule,
+  ValidatorConfig,
+} from './types';
+
+// Validators
+export { EmailValidator, PasswordValidator, NameValidator } from './validators';
+export type { PasswordConfig } from './validators';
+
+// Sanitizers
+export { EmailSanitizer, PasswordSanitizer, NameSanitizer } from './sanitizers';
+
+// Rules
+export { BaseValidationRule, RequiredRule, RegexRule, MinLengthRule } from './rules';

package/src/shared/validation/rules/ValidationRule.ts

@@ -0,0 +1,71 @@
+/**
+ * Validation Rule
+ * Base class and common validation rules
+ */
+
+import type { ValidationResult, ValidatorConfig } from '../types';
+
+export abstract class BaseValidationRule<T = any> {
+  abstract validate(value: T): ValidationResult;
+}
+
+/**
+ * Required field validation rule
+ */
+export class RequiredRule extends BaseValidationRule<string | null | undefined> {
+  constructor(private fieldName: string = 'Field') {
+    super();
+  }
+
+  validate(value: string | null | undefined): ValidationResult {
+    if (!value || value.trim() === '') {
+      return { isValid: false, error: `auth.validation.${thisFieldNameToKey()}.required` };
+    }
+    return { isValid: true };
+  }
+
+  private thisFieldNameToKey(): string {
+    const keyMap: Record<string, string> = {
+      'Field': 'field',
+      'Email': 'email',
+      'Password': 'password',
+      'Name': 'name',
+    };
+    return keyMap[this.fieldName] || 'field';
+  }
+}
+
+/**
+ * Regex validation rule
+ */
+export class RegexRule extends BaseValidationRule<string> {
+  constructor(
+    private regex: RegExp,
+    private errorKey: string
+  ) {
+    super();
+  }
+
+  validate(value: string): ValidationResult {
+    if (!this.regex.test(value)) {
+      return { isValid: false, error: this.errorKey };
+    }
+    return { isValid: true };
+  }
+}
+
+/**
+ * Min length validation rule
+ */
+export class MinLengthRule extends BaseValidationRule<string> {
+  constructor(private minLength: number, private errorKey: string) {
+    super();
+  }
+
+  validate(value: string): ValidationResult {
+    if (value.length < this.minLength) {
+      return { isValid: false, error: this.errorKey };
+    }
+    return { isValid: true };
+  }
+}

package/src/shared/validation/rules/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Validation Rules Public API
+ */
+
+export { BaseValidationRule, RequiredRule, RegexRule, MinLengthRule } from './ValidationRule';

package/src/shared/validation/sanitizers/EmailSanitizer.ts

@@ -0,0 +1,22 @@
+/**
+ * Email Sanitizer
+ * Handles email input sanitization
+ */
+
+export class EmailSanitizer {
+  /**
+   * Sanitize email input
+   * Trims whitespace and converts to lowercase
+   */
+  static sanitize(email: string | null | undefined): string {
+    if (!email) return '';
+    return email.trim().toLowerCase();
+  }
+
+  /**
+   * Check if email is empty
+   */
+  static isEmpty(email: string | null | undefined): boolean {
+    return !email || email.trim() === '';
+  }
+}

package/src/shared/validation/sanitizers/PasswordSanitizer.ts

@@ -0,0 +1,24 @@
+/**
+ * Password Sanitizer
+ * Handles password input sanitization
+ * IMPORTANT: Never trim passwords - whitespace may be intentional
+ */
+
+export class PasswordSanitizer {
+  /**
+   * Sanitize password input
+   * NOTE: Does NOT trim - whitespace may be intentional
+   */
+  static sanitize(password: string | null | undefined): string {
+    if (!password) return '';
+    return password; // Don't trim passwords
+  }
+
+  /**
+   * Check if password is empty
+   * NOTE: Does NOT trim - checks actual length
+   */
+  static isEmpty(password: string | null | undefined): boolean {
+    return !password || password.length === 0;
+  }
+}

package/src/shared/validation/sanitizers/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Sanitizers Public API
+ */
+
+export { EmailSanitizer } from './EmailSanitizer';
+export { PasswordSanitizer } from './PasswordSanitizer';
+export { NameSanitizer } from './NameSanitizer';

package/src/shared/validation/types.ts

@@ -0,0 +1,26 @@
+/**
+ * Validation Types
+ * Core types for validation system
+ */
+
+export interface ValidationResult {
+  isValid: boolean;
+  error?: string;
+}
+
+export interface PasswordRequirements {
+  hasMinLength: boolean;
+}
+
+export interface PasswordStrengthResult extends ValidationResult {
+  requirements?: PasswordRequirements;
+}
+
+export interface ValidationRule<T = any> {
+  validate(value: T): ValidationResult;
+}
+
+export interface ValidatorConfig {
+  emailRegex?: RegExp;
+  displayNameMinLength?: number;
+}

package/src/shared/validation/validators/EmailValidator.ts

@@ -0,0 +1,61 @@
+/**
+ * Email Validator
+ * Handles email validation with configurable rules
+ */
+
+import type { ValidationResult, ValidatorConfig } from '../types';
+import { RegexRule, RequiredRule } from '../rules/ValidationRule';
+import { EmailSanitizer } from '../sanitizers/EmailSanitizer';
+
+export class EmailValidator {
+  private config: ValidatorConfig;
+  private requiredRule: RequiredRule;
+  private regexRule: RegexRule;
+
+  constructor(config: ValidatorConfig = {}) {
+    this.config = {
+      emailRegex: config.emailRegex || this.getDefaultEmailRegex(),
+      displayNameMinLength: config.displayNameMinLength,
+    };
+
+    this.requiredRule = new RequiredRule('Email');
+    this.regexRule = new RegexRule(
+      this.config.emailRegex,
+      'auth.validation.invalidEmail'
+    );
+  }
+
+  /**
+   * Validate email
+   * @param email - Email to validate
+   * @returns Validation result
+   */
+  validate(email: string): ValidationResult {
+    // Check required
+    const requiredResult = this.requiredRule.validate(email);
+    if (!requiredResult.isValid) {
+      return requiredResult;
+    }
+
+    // Sanitize
+    const sanitized = EmailSanitizer.sanitize(email);
+
+    // Check format
+    return this.regexRule.validate(sanitized);
+  }
+
+  /**
+   * Check if email is empty
+   */
+  isEmpty(email: string | null | undefined): boolean {
+    return EmailSanitizer.isEmpty(email);
+  }
+
+  private getDefaultEmailRegex(): RegExp {
+    // More robust email validation:
+    // - Local part: alphanumeric, dots (not consecutive), hyphens, underscores, plus
+    // - Domain: alphanumeric and hyphens
+    // - TLD: at least 2 characters
+    return /^[a-zA-Z0-9]([a-zA-Z0-9._+-]*[a-zA-Z0-9])?@[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?)*\.[a-zA-Z]{2,}$/;
+  }
+}

package/src/shared/validation/validators/NameValidator.ts

@@ -0,0 +1,52 @@
+/**
+ * Name Validator
+ * Handles display name validation
+ */
+
+import type { ValidationResult, ValidatorConfig } from '../types';
+import { MinLengthRule, RequiredRule } from '../rules/ValidationRule';
+import { NameSanitizer } from '../sanitizers/NameSanitizer';
+
+export class NameValidator {
+  private config: ValidatorConfig;
+  private requiredRule: RequiredRule;
+  private minLengthRule: MinLengthRule;
+
+  constructor(config: ValidatorConfig = {}) {
+    this.config = {
+      displayNameMinLength: config.displayNameMinLength || 2,
+    };
+
+    this.requiredRule = new RequiredRule('Name');
+    this.minLengthRule = new MinLengthRule(
+      this.config.displayNameMinLength,
+      'auth.validation.nameTooShort'
+    );
+  }
+
+  /**
+   * Validate display name
+   * @param name - Name to validate
+   * @returns Validation result
+   */
+  validate(name: string): ValidationResult {
+    // Check required
+    const requiredResult = this.requiredRule.validate(name);
+    if (!requiredResult.isValid) {
+      return { isValid: false, error: 'auth.validation.nameRequired' };
+    }
+
+    // Sanitize
+    const sanitized = NameSanitizer.sanitize(name);
+
+    // Check min length
+    return this.minLengthRule.validate(sanitized);
+  }
+
+  /**
+   * Check if name is empty
+   */
+  isEmpty(name: string | null | undefined): boolean {
+    return NameSanitizer.isEmpty(name);
+  }
+}

package/src/shared/validation/validators/PasswordValidator.ts

@@ -0,0 +1,92 @@
+/**
+ * Password Validator
+ * Handles password validation with strength requirements
+ */
+
+import type { PasswordStrengthResult, ValidationResult, ValidatorConfig } from '../types';
+import { MinLengthRule, RequiredRule } from '../rules/ValidationRule';
+import { PasswordSanitizer } from '../sanitizers/PasswordSanitizer';
+
+export interface PasswordConfig {
+  minLength: number;
+}
+
+export class PasswordValidator {
+  private config: PasswordConfig;
+  private requiredRule: RequiredRule;
+
+  constructor(config: PasswordConfig) {
+    this.config = config;
+    this.requiredRule = new RequiredRule('Password');
+  }
+
+  /**
+   * Validate password for login (just check required)
+   * @param password - Password to validate
+   * @returns Validation result
+   */
+  validateForLogin(password: string): ValidationResult {
+    // Don't trim passwords - whitespace may be intentional
+    if (PasswordSanitizer.isEmpty(password)) {
+      return { isValid: false, error: 'auth.validation.passwordRequired' };
+    }
+    return { isValid: true };
+  }
+
+  /**
+   * Validate password for registration (check requirements)
+   * @param password - Password to validate
+   * @returns Password strength result
+   */
+  validateForRegister(password: string): PasswordStrengthResult {
+    // Don't trim passwords - whitespace may be intentional
+    if (PasswordSanitizer.isEmpty(password)) {
+      return {
+        isValid: false,
+        error: 'auth.validation.passwordRequired',
+        requirements: { hasMinLength: false },
+      };
+    }
+
+    const hasMinLength = password.length >= this.config.minLength;
+
+    if (!hasMinLength) {
+      return {
+        isValid: false,
+        error: 'auth.validation.passwordTooShort',
+        requirements: { hasMinLength: false },
+      };
+    }
+
+    return {
+      isValid: true,
+      requirements: { hasMinLength: true },
+    };
+  }
+
+  /**
+   * Validate password confirmation matches
+   * @param password - Original password
+   * @param confirm - Confirmation password
+   * @returns Validation result
+   */
+  validateConfirmation(password: string, confirm: string): ValidationResult {
+    // Don't trim passwords - whitespace may be intentional
+    if (PasswordSanitizer.isEmpty(confirm)) {
+      return { isValid: false, error: 'auth.validation.confirmPasswordRequired' };
+    }
+
+    if (password !== confirm) {
+      return { isValid: false, error: 'auth.validation.passwordsDoNotMatch' };
+    }
+
+    return { isValid: true };
+  }
+
+  /**
+   * Check if password is empty
+   */
+  isEmpty(password: string | null | undefined): boolean {
+    return PasswordSanitizer.isEmpty(password);
+  }
+}

package/src/shared/validation/validators/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Validators Public API
+ */
+
+export { EmailValidator } from './EmailValidator';
+export { PasswordValidator } from './PasswordValidator';
+export type { PasswordConfig } from './PasswordValidator';
+export { NameValidator } from './NameValidator';