@hy_ong/zod-kit 0.0.4 → 0.0.6

package/src/validators/common/number.ts

@@ -0,0 +1,319 @@
+/**
+ * @fileoverview Number validator for Zod Kit
+ *
+ * Provides comprehensive number validation with type constraints, range validation,
+ * precision control, and advanced parsing features including comma-separated numbers.
+ *
+ * @author Ong Hoe Yuan
+ * @version 0.0.5
+ */
+
+import { z, ZodNullable, ZodNumber } from "zod"
+import { t } from "../../i18n"
+import { getLocale, type Locale } from "../../config"
+
+/**
+ * Type definition for number validation error messages
+ *
+ * @interface NumberMessages
+ * @property {string} [required] - Message when field is required but empty
+ * @property {string} [invalid] - Message when value is not a valid number
+ * @property {string} [integer] - Message when integer is required but float provided
+ * @property {string} [float] - Message when float is required but integer provided
+ * @property {string} [min] - Message when number is below minimum value
+ * @property {string} [max] - Message when number exceeds maximum value
+ * @property {string} [positive] - Message when positive number is required
+ * @property {string} [negative] - Message when negative number is required
+ * @property {string} [nonNegative] - Message when non-negative number is required
+ * @property {string} [nonPositive] - Message when non-positive number is required
+ * @property {string} [multipleOf] - Message when number is not a multiple of specified value
+ * @property {string} [finite] - Message when finite number is required
+ * @property {string} [precision] - Message when number has too many decimal places
+ */
+export type NumberMessages = {
+  required?: string
+  invalid?: string
+  integer?: string
+  float?: string
+  min?: string
+  max?: string
+  positive?: string
+  negative?: string
+  nonNegative?: string
+  nonPositive?: string
+  multipleOf?: string
+  finite?: string
+  precision?: string
+}
+
+/**
+ * Configuration options for number validation
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ *
+ * @interface NumberOptions
+ * @property {IsRequired} [required=true] - Whether the field is required
+ * @property {number} [min] - Minimum allowed value
+ * @property {number} [max] - Maximum allowed value
+ * @property {number | null} [defaultValue] - Default value when input is empty
+ * @property {"integer" | "float" | "both"} [type="both"] - Type constraint for the number
+ * @property {boolean} [positive] - Whether number must be positive (> 0)
+ * @property {boolean} [negative] - Whether number must be negative (< 0)
+ * @property {boolean} [nonNegative] - Whether number must be non-negative (>= 0)
+ * @property {boolean} [nonPositive] - Whether number must be non-positive (<= 0)
+ * @property {number} [multipleOf] - Number must be a multiple of this value
+ * @property {number} [precision] - Maximum number of decimal places allowed
+ * @property {boolean} [finite=true] - Whether to reject Infinity and -Infinity
+ * @property {Function} [transform] - Custom transformation function for number values
+ * @property {boolean} [parseCommas=false] - Whether to parse comma-separated numbers (e.g., "1,234")
+ * @property {Record<Locale, NumberMessages>} [i18n] - Custom error messages for different locales
+ */
+export type NumberOptions<IsRequired extends boolean = true> = {
+  required?: IsRequired
+  min?: number
+  max?: number
+  defaultValue?: IsRequired extends true ? number : number | null
+  type?: "integer" | "float" | "both"
+  positive?: boolean
+  negative?: boolean
+  nonNegative?: boolean
+  nonPositive?: boolean
+  multipleOf?: number
+  precision?: number
+  finite?: boolean
+  transform?: (value: number) => number
+  parseCommas?: boolean // Parse "1,234" as 1234
+  i18n?: Record<Locale, NumberMessages>
+}
+
+/**
+ * Type alias for number validation schema based on required flag
+ *
+ * @template IsRequired - Whether the field is required
+ * @typedef NumberSchema
+ * @description Returns ZodNumber if required, ZodNullable<ZodNumber> if optional
+ */
+export type NumberSchema<IsRequired extends boolean> = IsRequired extends true ? ZodNumber : ZodNullable<ZodNumber>
+
+/**
+ * Creates a Zod schema for number validation with comprehensive constraints
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ * @param {NumberOptions<IsRequired>} [options] - Configuration options for number validation
+ * @returns {NumberSchema<IsRequired>} Zod schema for number validation
+ *
+ * @description
+ * Creates a comprehensive number validator with type constraints, range validation,
+ * precision control, and advanced parsing features including comma-separated numbers.
+ *
+ * Features:
+ * - Type constraints (integer, float, or both)
+ * - Range validation (min/max)
+ * - Sign constraints (positive, negative, non-negative, non-positive)
+ * - Multiple-of validation
+ * - Precision control (decimal places)
+ * - Finite number validation
+ * - Comma-separated number parsing
+ * - Custom transformation functions
+ * - Comprehensive internationalization
+ *
+ * @example
+ * ```typescript
+ * // Basic number validation
+ * const basicSchema = number()
+ * basicSchema.parse(42) // ✓ Valid
+ * basicSchema.parse("42") // ✓ Valid (converted to number)
+ *
+ * // Integer only
+ * const integerSchema = number({ type: "integer" })
+ * integerSchema.parse(42) // ✓ Valid
+ * integerSchema.parse(42.5) // ✗ Invalid
+ *
+ * // Range validation
+ * const rangeSchema = number({ min: 0, max: 100 })
+ * rangeSchema.parse(50) // ✓ Valid
+ * rangeSchema.parse(150) // ✗ Invalid
+ *
+ * // Positive numbers only
+ * const positiveSchema = number({ positive: true })
+ * positiveSchema.parse(5) // ✓ Valid
+ * positiveSchema.parse(-5) // ✗ Invalid
+ *
+ * // Multiple of constraint
+ * const multipleSchema = number({ multipleOf: 5 })
+ * multipleSchema.parse(10) // ✓ Valid
+ * multipleSchema.parse(7) // ✗ Invalid
+ *
+ * // Precision control
+ * const precisionSchema = number({ precision: 2 })
+ * precisionSchema.parse(3.14) // ✓ Valid
+ * precisionSchema.parse(3.14159) // ✗ Invalid
+ *
+ * // Comma-separated parsing
+ * const commaSchema = number({ parseCommas: true })
+ * commaSchema.parse("1,234.56") // ✓ Valid (parsed as 1234.56)
+ *
+ * // Optional with default
+ * const optionalSchema = number({
+ *   required: false,
+ *   defaultValue: 0
+ * })
+ * ```
+ *
+ * @throws {z.ZodError} When validation fails with specific error messages
+ * @see {@link NumberOptions} for all available configuration options
+ */
+export function number<IsRequired extends boolean = true>(options?: NumberOptions<IsRequired>): NumberSchema<IsRequired> {
+  const {
+    required = true,
+    min,
+    max,
+    defaultValue,
+    type = "both",
+    positive,
+    negative,
+    nonNegative,
+    nonPositive,
+    multipleOf,
+    precision,
+    finite = true,
+    transform,
+    parseCommas = false,
+    i18n,
+  } = options ?? {}
+
+  // Helper function to get custom message or fallback to default i18n
+  const getMessage = (key: keyof NumberMessages, params?: Record<string, any>) => {
+    if (i18n) {
+      const currentLocale = getLocale()
+      const customMessages = i18n[currentLocale]
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key]!
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "")
+      }
+    }
+    return t(`common.number.${key}`, params)
+  }
+
+  // Set appropriate default value based on required flag
+  const actualDefaultValue = defaultValue ?? null
+
+  const schema = z
+    .preprocess(
+      (val) => {
+        if (val === "" || val === undefined || val === null) {
+          return actualDefaultValue
+        }
+
+        // Handle string input
+        if (typeof val === "string") {
+          let processedVal = val.trim()
+
+          // Parse comma-separated numbers like "1,234.56"
+          if (parseCommas) {
+            processedVal = processedVal.replace(/,/g, "")
+          }
+
+          const parsed = Number(processedVal)
+
+          // Return NaN as is so it can be caught in refine
+          if (isNaN(parsed)) {
+            return parsed
+          }
+
+          if (transform) {
+            return transform(parsed)
+          }
+
+          return parsed
+        }
+
+        // Handle existing numbers (including Infinity)
+        if (typeof val === "number") {
+          if (transform && Number.isFinite(val)) {
+            return transform(val)
+          }
+          return val
+        }
+
+        return val
+      },
+      z.union([z.number(), z.null(), z.nan(), z.custom<number>((val) => val === Infinity || val === -Infinity)])
+    )
+    .refine((val) => {
+      // Required check first
+      if (required && val === null) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("required"), path: [] }])
+      }
+
+      if (val === null) return true
+
+      // Type validation for invalid inputs (NaN)
+      if (typeof val === "number" && isNaN(val)) {
+        if (type === "integer") {
+          throw new z.ZodError([{ code: "custom", message: getMessage("integer"), path: [] }])
+        } else if (type === "float") {
+          throw new z.ZodError([{ code: "custom", message: getMessage("float"), path: [] }])
+        } else {
+          throw new z.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }])
+        }
+      }
+
+      // Invalid number check for non-numbers
+      if (typeof val !== "number") {
+        throw new z.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }])
+      }
+
+      // Finite check
+      if (finite && !Number.isFinite(val)) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("finite"), path: [] }])
+      }
+
+      // Type validation for valid numbers
+      if (type === "integer" && !Number.isInteger(val)) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("integer"), path: [] }])
+      }
+      if (type === "float" && Number.isInteger(val)) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("float"), path: [] }])
+      }
+
+      // Sign checks (more specific, should come first)
+      if (positive && val <= 0) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("positive"), path: [] }])
+      }
+      if (negative && val >= 0) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("negative"), path: [] }])
+      }
+      if (nonNegative && val < 0) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("nonNegative"), path: [] }])
+      }
+      if (nonPositive && val > 0) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("nonPositive"), path: [] }])
+      }
+
+      // Range checks
+      if (min !== undefined && val < min) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("min", { min }), path: [] }])
+      }
+      if (max !== undefined && val > max) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("max", { max }), path: [] }])
+      }
+
+      // Multiple of check
+      if (multipleOf !== undefined && val % multipleOf !== 0) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("multipleOf", { multipleOf }), path: [] }])
+      }
+
+      // Precision check
+      if (precision !== undefined) {
+        const decimalPlaces = (val.toString().split(".")[1] || "").length
+        if (decimalPlaces > precision) {
+          throw new z.ZodError([{ code: "custom", message: getMessage("precision", { precision }), path: [] }])
+        }
+      }
+
+      return true
+    })
+
+  return schema as unknown as NumberSchema<IsRequired>
+}

package/src/validators/common/password.ts

@@ -0,0 +1,386 @@
+/**
+ * @fileoverview Password validator for Zod Kit
+ *
+ * Provides comprehensive password validation with strength analysis, character requirements,
+ * security checks, and protection against common weak passwords.
+ *
+ * @author Ong Hoe Yuan
+ * @version 0.0.5
+ */
+
+import { z, ZodNullable, ZodString } from "zod"
+import { t } from "../../i18n"
+import { getLocale, type Locale } from "../../config"
+
+/**
+ * Type definition for password validation error messages
+ *
+ * @interface PasswordMessages
+ * @property {string} [required] - Message when field is required but empty
+ * @property {string} [min] - Message when password is too short
+ * @property {string} [max] - Message when password is too long
+ * @property {string} [uppercase] - Message when uppercase letters are required
+ * @property {string} [lowercase] - Message when lowercase letters are required
+ * @property {string} [digits] - Message when digits are required
+ * @property {string} [special] - Message when special characters are required
+ * @property {string} [noRepeating] - Message when repeating characters are forbidden
+ * @property {string} [noSequential] - Message when sequential characters are forbidden
+ * @property {string} [noCommonWords] - Message when common passwords are forbidden
+ * @property {string} [minStrength] - Message when password strength is insufficient
+ * @property {string} [excludes] - Message when password contains forbidden strings
+ * @property {string} [includes] - Message when password doesn't contain required string
+ * @property {string} [invalid] - Message when password doesn't match custom regex
+ */
+export type PasswordMessages = {
+  required?: string
+  min?: string
+  max?: string
+  uppercase?: string
+  lowercase?: string
+  digits?: string
+  special?: string
+  noRepeating?: string
+  noSequential?: string
+  noCommonWords?: string
+  minStrength?: string
+  excludes?: string
+  includes?: string
+  invalid?: string
+}
+
+/**
+ * Password strength levels used for validation
+ *
+ * @typedef {"weak" | "medium" | "strong" | "very-strong"} PasswordStrength
+ * @description
+ * - weak: Basic passwords with minimal requirements
+ * - medium: Passwords with some character variety
+ * - strong: Passwords with good character variety and length
+ * - very-strong: Passwords with excellent character variety, length, and complexity
+ */
+export type PasswordStrength = "weak" | "medium" | "strong" | "very-strong"
+
+/**
+ * Configuration options for password validation
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ *
+ * @interface PasswordOptions
+ * @property {IsRequired} [required=true] - Whether the field is required
+ * @property {number} [min] - Minimum length of password
+ * @property {number} [max] - Maximum length of password
+ * @property {boolean} [uppercase] - Whether uppercase letters are required
+ * @property {boolean} [lowercase] - Whether lowercase letters are required
+ * @property {boolean} [digits] - Whether digits are required
+ * @property {boolean} [special] - Whether special characters are required
+ * @property {boolean} [noRepeating] - Whether to forbid repeating characters (3+ in a row)
+ * @property {boolean} [noSequential] - Whether to forbid sequential characters (abc, 123)
+ * @property {boolean} [noCommonWords] - Whether to forbid common weak passwords
+ * @property {PasswordStrength} [minStrength] - Minimum required password strength
+ * @property {string | string[]} [excludes] - String(s) that must not be included
+ * @property {string} [includes] - String that must be included in password
+ * @property {RegExp} [regex] - Custom regex pattern for validation
+ * @property {Function} [transform] - Custom transformation function for password
+ * @property {string | null} [defaultValue] - Default value when input is empty
+ * @property {Record<Locale, PasswordMessages>} [i18n] - Custom error messages for different locales
+ */
+export type PasswordOptions<IsRequired extends boolean = true> = {
+  required?: IsRequired
+  min?: number
+  max?: number
+  uppercase?: boolean
+  lowercase?: boolean
+  digits?: boolean
+  special?: boolean
+  noRepeating?: boolean
+  noSequential?: boolean
+  noCommonWords?: boolean
+  minStrength?: PasswordStrength
+  excludes?: string | string[]
+  includes?: string
+  regex?: RegExp
+  transform?: (value: string) => string
+  defaultValue?: IsRequired extends true ? string : string | null
+  i18n?: Record<Locale, PasswordMessages>
+}
+
+/**
+ * Type alias for password validation schema based on required flag
+ *
+ * @template IsRequired - Whether the field is required
+ * @typedef PasswordSchema
+ * @description Returns ZodString if required, ZodNullable<ZodString> if optional
+ */
+export type PasswordSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>
+
+/**
+ * List of common weak passwords to check against
+ *
+ * @constant {string[]} COMMON_PASSWORDS
+ * @description Contains frequently used weak passwords that should be avoided
+ */
+const COMMON_PASSWORDS = [
+  "password",
+  "123456",
+  "123456789",
+  "12345678",
+  "12345",
+  "1234567",
+  "admin",
+  "qwerty",
+  "abc123",
+  "password123",
+  "letmein",
+  "welcome",
+  "monkey",
+  "dragon",
+  "sunshine",
+  "princess",
+]
+
+/**
+ * Calculates password strength based on various criteria
+ *
+ * @param {string} password - The password to analyze
+ * @returns {PasswordStrength} The calculated strength level
+ *
+ * @description
+ * Analyzes password strength using multiple factors:
+ * - Length bonuses (8+, 12+, 16+ characters)
+ * - Character variety (lowercase, uppercase, digits, special characters)
+ * - Deductions for repeating or sequential patterns
+ *
+ * Scoring system:
+ * - 0-2 points: weak
+ * - 3-4 points: medium
+ * - 5-6 points: strong
+ * - 7+ points: very-strong
+ *
+ * @example
+ * ```typescript
+ * calculatePasswordStrength("password") // "weak"
+ * calculatePasswordStrength("Password123") // "medium"
+ * calculatePasswordStrength("MyStr0ng!P@ssw0rd") // "very-strong"
+ * ```
+ */
+const calculatePasswordStrength = (password: string): PasswordStrength => {
+  let score = 0
+
+  // Length bonus
+  if (password.length >= 8) score += 1
+  if (password.length >= 12) score += 1
+  if (password.length >= 16) score += 1
+
+  // Character variety
+  if (/[a-z]/.test(password)) score += 1
+  if (/[A-Z]/.test(password)) score += 1
+  if (/[0-9]/.test(password)) score += 1
+  if (/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(password)) score += 1
+
+  // Deductions
+  if (/(.)\1{2,}/.test(password)) score -= 1 // Repeating characters
+  if (/(?:abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|tuv|uvw|vwx|wxy|xyz|012|123|234|345|456|567|678|789)/i.test(password)) score -= 1 // Sequential
+
+  if (score <= 2) return "weak"
+  if (score <= 4) return "medium"
+  if (score <= 6) return "strong"
+  return "very-strong"
+}
+
+/**
+ * Creates a Zod schema for password validation with comprehensive security checks
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ * @param {PasswordOptions<IsRequired>} [options] - Configuration options for password validation
+ * @returns {PasswordSchema<IsRequired>} Zod schema for password validation
+ *
+ * @description
+ * Creates a comprehensive password validator with strength analysis, character requirements,
+ * security checks, and protection against common weak passwords.
+ *
+ * Features:
+ * - Length validation (min/max)
+ * - Character requirements (uppercase, lowercase, digits, special)
+ * - Security checks (no repeating, no sequential patterns)
+ * - Common password detection
+ * - Strength analysis with configurable minimum levels
+ * - Content inclusion/exclusion
+ * - Custom regex patterns
+ * - Custom transformation functions
+ * - Comprehensive internationalization
+ *
+ * @example
+ * ```typescript
+ * // Basic password validation
+ * const basicSchema = password()
+ * basicSchema.parse("MyPassword123!") // ✓ Valid
+ *
+ * // Strong password requirements
+ * const strongSchema = password({
+ *   min: 12,
+ *   uppercase: true,
+ *   lowercase: true,
+ *   digits: true,
+ *   special: true,
+ *   minStrength: "strong"
+ * })
+ *
+ * // No common passwords
+ * const secureSchema = password({
+ *   noCommonWords: true,
+ *   noRepeating: true,
+ *   noSequential: true
+ * })
+ * secureSchema.parse("password123") // ✗ Invalid (common password)
+ * secureSchema.parse("aaa123") // ✗ Invalid (repeating characters)
+ * secureSchema.parse("abc123") // ✗ Invalid (sequential characters)
+ *
+ * // Custom requirements
+ * const customSchema = password({
+ *   min: 8,
+ *   includes: "@", // Must contain @
+ *   excludes: ["admin", "user"], // Cannot contain these words
+ *   regex: /^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)/ // Custom pattern
+ * })
+ *
+ * // Minimum strength requirement
+ * const strengthSchema = password({ minStrength: "very-strong" })
+ * strengthSchema.parse("weak") // ✗ Invalid (insufficient strength)
+ * strengthSchema.parse("MyVeryStr0ng!P@ssw0rd2024") // ✓ Valid
+ *
+ * // Optional with default
+ * const optionalSchema = password({
+ *   required: false,
+ *   defaultValue: null
+ * })
+ * ```
+ *
+ * @throws {z.ZodError} When validation fails with specific error messages
+ * @see {@link PasswordOptions} for all available configuration options
+ * @see {@link PasswordStrength} for strength level definitions
+ * @see {@link calculatePasswordStrength} for strength calculation logic
+ */
+export function password<IsRequired extends boolean = true>(options?: PasswordOptions<IsRequired>): PasswordSchema<IsRequired> {
+  const {
+    required = true,
+    min,
+    max,
+    uppercase,
+    lowercase,
+    digits,
+    special,
+    noRepeating,
+    noSequential,
+    noCommonWords,
+    minStrength,
+    excludes,
+    includes,
+    regex,
+    transform,
+    defaultValue,
+    i18n,
+  } = options ?? {}
+
+  // Set appropriate default value based on required flag
+  const actualDefaultValue = defaultValue ?? (required ? "" : null)
+
+  // Helper function to get custom message or fallback to default i18n
+  const getMessage = (key: keyof PasswordMessages, params?: Record<string, any>) => {
+    if (i18n) {
+      const currentLocale = getLocale()
+      const customMessages = i18n[currentLocale]
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key]!
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "")
+      }
+    }
+    return t(`common.password.${key}`, params)
+  }
+
+  // Preprocessing function
+  const preprocessFn = (val: unknown) => {
+    if (val === "" || val === null || val === undefined) {
+      return actualDefaultValue
+    }
+
+    let processed = String(val)
+    if (transform) {
+      processed = transform(processed)
+    }
+
+    return processed
+  }
+
+  const baseSchema = required ? z.preprocess(preprocessFn, z.string()) : z.preprocess(preprocessFn, z.string().nullable())
+
+  const schema = baseSchema.refine((val) => {
+    if (val === null) return true
+
+    // Required check
+    if (required && (val === "" || val === "null" || val === "undefined")) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("required"), path: [] }])
+    }
+
+    // Length checks
+    if (val !== null && min !== undefined && val.length < min) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("min", { min }), path: [] }])
+    }
+    if (val !== null && max !== undefined && val.length > max) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("max", { max }), path: [] }])
+    }
+
+    // Character requirements
+    if (val !== null && uppercase && !/[A-Z]/.test(val)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("uppercase"), path: [] }])
+    }
+    if (val !== null && lowercase && !/[a-z]/.test(val)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("lowercase"), path: [] }])
+    }
+    if (val !== null && digits && !/[0-9]/.test(val)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("digits"), path: [] }])
+    }
+    if (val !== null && special && !/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(val)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("special"), path: [] }])
+    }
+
+    // Advanced security checks
+    if (val !== null && noRepeating && /(.)\1{2,}/.test(val)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("noRepeating"), path: [] }])
+    }
+    if (val !== null && noSequential && /(?:abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|tuv|uvw|vwx|wxy|xyz|012|123|234|345|456|567|678|789)/i.test(val)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("noSequential"), path: [] }])
+    }
+    if (val !== null && noCommonWords && COMMON_PASSWORDS.some((common) => val.toLowerCase().includes(common.toLowerCase()))) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("noCommonWords"), path: [] }])
+    }
+    if (val !== null && minStrength) {
+      const strength = calculatePasswordStrength(val)
+      const strengthLevels = ["weak", "medium", "strong", "very-strong"]
+      const currentLevel = strengthLevels.indexOf(strength)
+      const requiredLevel = strengthLevels.indexOf(minStrength)
+      if (currentLevel < requiredLevel) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("minStrength", { minStrength }), path: [] }])
+      }
+    }
+
+    // Content checks
+    if (val !== null && includes !== undefined && !val.includes(includes)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("includes", { includes }), path: [] }])
+    }
+    if (val !== null && excludes !== undefined) {
+      const excludeList = Array.isArray(excludes) ? excludes : [excludes]
+      for (const exclude of excludeList) {
+        if (val.includes(exclude)) {
+          throw new z.ZodError([{ code: "custom", message: getMessage("excludes", { excludes: exclude }), path: [] }])
+        }
+      }
+    }
+    if (val !== null && regex !== undefined && !regex.test(val)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("invalid", { regex }), path: [] }])
+    }
+
+    return true
+  })
+
+  return schema as unknown as PasswordSchema<IsRequired>
+}