@hy_ong/zod-kit 0.2.0 → 0.2.2

package/dist/common/number.cjs

@@ -0,0 +1,7 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkEGHL277Kcjs = require('../chunk-EGHL277K.cjs');
+require('../chunk-UCOXAZJF.cjs');
+
+
+exports.number = _chunkEGHL277Kcjs.number;

package/dist/common/number.d.cts

@@ -0,0 +1,167 @@
+import { ZodNumber, ZodNullable } from 'zod';
+import { L as Locale } from '../config-CABSSvAp.cjs';
+
+/**
+ * @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
+ */
+
+/**
+ * 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
+ */
+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
+ */
+type NumberOptions<IsRequired extends boolean = true> = {
+    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;
+    i18n?: Partial<Record<Locale, Partial<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
+ */
+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 required
+ * @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 (optional by default)
+ * const basicSchema = number()
+ * basicSchema.parse(42) // ✓ Valid
+ * basicSchema.parse("42") // ✓ Valid (converted to number)
+ * basicSchema.parse(null) // ✓ Valid (optional)
+ *
+ * // Required number
+ * const requiredSchema = number(true)
+ * requiredSchema.parse(42) // ✓ Valid
+ * requiredSchema.parse(null) // ✗ Invalid (required)
+ *
+ * // Integer only
+ * const integerSchema = number(false, { type: "integer" })
+ * integerSchema.parse(42) // ✓ Valid
+ * integerSchema.parse(42.5) // ✗ Invalid
+ *
+ * // Range validation
+ * const rangeSchema = number(true, { min: 0, max: 100 })
+ * rangeSchema.parse(50) // ✓ Valid
+ * rangeSchema.parse(150) // ✗ Invalid
+ *
+ * // Positive numbers only
+ * const positiveSchema = number(true, { positive: true })
+ * positiveSchema.parse(5) // ✓ Valid
+ * positiveSchema.parse(-5) // ✗ Invalid
+ *
+ * // Multiple of constraint
+ * const multipleSchema = number(true, { multipleOf: 5 })
+ * multipleSchema.parse(10) // ✓ Valid
+ * multipleSchema.parse(7) // ✗ Invalid
+ *
+ * // Precision control
+ * const precisionSchema = number(true, { precision: 2 })
+ * precisionSchema.parse(3.14) // ✓ Valid
+ * precisionSchema.parse(3.14159) // ✗ Invalid
+ *
+ * // Comma-separated parsing
+ * const commaSchema = number(false, { parseCommas: true })
+ * commaSchema.parse("1,234.56") // ✓ Valid (parsed as 1234.56)
+ *
+ * // Optional with default
+ * const optionalSchema = number(false, { defaultValue: 0 })
+ * ```
+ *
+ * @throws {z.ZodError} When validation fails with specific error messages
+ * @see {@link NumberOptions} for all available configuration options
+ */
+declare function number<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<NumberOptions<IsRequired>, "required">): NumberSchema<IsRequired>;
+
+export { type NumberMessages, type NumberOptions, type NumberSchema, number };

package/dist/common/number.d.ts

@@ -0,0 +1,167 @@
+import { ZodNumber, ZodNullable } from 'zod';
+import { L as Locale } from '../config-CABSSvAp.js';
+
+/**
+ * @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
+ */
+
+/**
+ * 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
+ */
+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
+ */
+type NumberOptions<IsRequired extends boolean = true> = {
+    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;
+    i18n?: Partial<Record<Locale, Partial<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
+ */
+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 required
+ * @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 (optional by default)
+ * const basicSchema = number()
+ * basicSchema.parse(42) // ✓ Valid
+ * basicSchema.parse("42") // ✓ Valid (converted to number)
+ * basicSchema.parse(null) // ✓ Valid (optional)
+ *
+ * // Required number
+ * const requiredSchema = number(true)
+ * requiredSchema.parse(42) // ✓ Valid
+ * requiredSchema.parse(null) // ✗ Invalid (required)
+ *
+ * // Integer only
+ * const integerSchema = number(false, { type: "integer" })
+ * integerSchema.parse(42) // ✓ Valid
+ * integerSchema.parse(42.5) // ✗ Invalid
+ *
+ * // Range validation
+ * const rangeSchema = number(true, { min: 0, max: 100 })
+ * rangeSchema.parse(50) // ✓ Valid
+ * rangeSchema.parse(150) // ✗ Invalid
+ *
+ * // Positive numbers only
+ * const positiveSchema = number(true, { positive: true })
+ * positiveSchema.parse(5) // ✓ Valid
+ * positiveSchema.parse(-5) // ✗ Invalid
+ *
+ * // Multiple of constraint
+ * const multipleSchema = number(true, { multipleOf: 5 })
+ * multipleSchema.parse(10) // ✓ Valid
+ * multipleSchema.parse(7) // ✗ Invalid
+ *
+ * // Precision control
+ * const precisionSchema = number(true, { precision: 2 })
+ * precisionSchema.parse(3.14) // ✓ Valid
+ * precisionSchema.parse(3.14159) // ✗ Invalid
+ *
+ * // Comma-separated parsing
+ * const commaSchema = number(false, { parseCommas: true })
+ * commaSchema.parse("1,234.56") // ✓ Valid (parsed as 1234.56)
+ *
+ * // Optional with default
+ * const optionalSchema = number(false, { defaultValue: 0 })
+ * ```
+ *
+ * @throws {z.ZodError} When validation fails with specific error messages
+ * @see {@link NumberOptions} for all available configuration options
+ */
+declare function number<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<NumberOptions<IsRequired>, "required">): NumberSchema<IsRequired>;
+
+export { type NumberMessages, type NumberOptions, type NumberSchema, number };

package/dist/common/number.js

@@ -0,0 +1,7 @@
+import {
+  number
+} from "../chunk-FM3EZ72O.js";
+import "../chunk-6AAP4LPF.js";
+export {
+  number
+};

package/dist/common/password.cjs

@@ -0,0 +1,7 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkYPSEIDURcjs = require('../chunk-YPSEIDUR.cjs');
+require('../chunk-UCOXAZJF.cjs');
+
+
+exports.password = _chunkYPSEIDURcjs.password;

package/dist/common/password.d.cts

@@ -0,0 +1,192 @@
+import { ZodString, ZodNullable } from 'zod';
+import { L as Locale } from '../config-CABSSvAp.cjs';
+
+/**
+ * @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
+ */
+
+/**
+ * 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
+ */
+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
+ */
+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
+ */
+type PasswordOptions<IsRequired extends boolean = true> = {
+    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?: Partial<Record<Locale, Partial<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
+ */
+type PasswordSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>;
+/**
+ * Creates a Zod schema for password validation with comprehensive security checks
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ * @param {IsRequired} [required=false] - Whether the field is required
+ * @param {Omit<ValidatorOptions<IsRequired>, 'required'>} [options] - Configuration options for 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() // optional by default
+ * basicSchema.parse("MyPassword123!") // ✓ Valid
+ * basicSchema.parse(null) // ✓ Valid (optional)
+ *
+ * // Required validation
+ * const requiredSchema = parse("MyPassword123!") // ✓ Valid
+(true)
+ * requiredSchema.parse(null) // ✗ Invalid (required)
+ *
+ *
+ * // Strong password requirements
+ * const strongSchema = password(false, {
+ *   min: 12,
+ *   uppercase: true,
+ *   lowercase: true,
+ *   digits: true,
+ *   special: true,
+ *   minStrength: "strong"
+ * })
+ *
+ * // No common passwords
+ * const secureSchema = password(false, {
+ *   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(false, {
+ *   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(false, { minStrength: "very-strong" })
+ * strengthSchema.parse("weak") // ✗ Invalid (insufficient strength)
+ * strengthSchema.parse("MyVeryStr0ng!P@ssw0rd2024") // ✓ Valid
+ *
+ * // Optional with default
+ * const optionalSchema = password(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
+ */
+declare function password<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<PasswordOptions<IsRequired>, 'required'>): PasswordSchema<IsRequired>;
+
+export { type PasswordMessages, type PasswordOptions, type PasswordSchema, type PasswordStrength, password };