@hy_ong/zod-kit 0.2.0 → 0.2.2

package/dist/common/password.d.ts

@@ -0,0 +1,192 @@
+import { ZodString, ZodNullable } from 'zod';
+import { L as Locale } from '../config-CABSSvAp.js';
+
+/**
+ * @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 };

package/dist/common/password.js

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

package/dist/common/text.cjs

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

package/dist/common/text.d.cts

@@ -0,0 +1,156 @@
+import { ZodString, ZodNullable } from 'zod';
+import { L as Locale } from '../config-CABSSvAp.cjs';
+
+/**
+ * @fileoverview Text validator for Zod Kit
+ *
+ * Provides comprehensive text validation with length constraints, content validation,
+ * flexible trimming and casing options, and advanced transformation features.
+ *
+ * @author Ong Hoe Yuan
+ * @version 0.0.5
+ */
+
+/**
+ * Type definition for text validation error messages
+ *
+ * @interface TextMessages
+ * @property {string} [required] - Message when field is required but empty
+ * @property {string} [notEmpty] - Message when field must not be empty (whitespace-only)
+ * @property {string} [minLength] - Message when text is shorter than minimum length
+ * @property {string} [maxLength] - Message when text exceeds maximum length
+ * @property {string} [startsWith] - Message when text doesn't start with required string
+ * @property {string} [endsWith] - Message when text doesn't end with required string
+ * @property {string} [includes] - Message when text doesn't contain required string
+ * @property {string} [excludes] - Message when text contains forbidden string
+ * @property {string} [invalid] - Message when text doesn't match regex pattern
+ */
+type TextMessages = {
+    required?: string;
+    notEmpty?: string;
+    minLength?: string;
+    maxLength?: string;
+    startsWith?: string;
+    endsWith?: string;
+    includes?: string;
+    excludes?: string;
+    invalid?: string;
+};
+/**
+ * Configuration options for text validation
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ *
+ * @interface TextOptions
+ * @property {IsRequired} [required=true] - Whether the field is required
+ * @property {number} [minLength] - Minimum length of text
+ * @property {number} [maxLength] - Maximum length of text
+ * @property {string} [startsWith] - String that text must start with
+ * @property {string} [endsWith] - String that text must end with
+ * @property {string} [includes] - String that must be included in text
+ * @property {string | string[]} [excludes] - String(s) that must not be included
+ * @property {RegExp} [regex] - Regular expression pattern for validation
+ * @property {"trim" | "trimStart" | "trimEnd" | "none"} [trimMode="trim"] - Whitespace handling
+ * @property {"upper" | "lower" | "title" | "none"} [casing="none"] - Case transformation
+ * @property {Function} [transform] - Custom transformation function for text
+ * @property {boolean} [notEmpty] - Whether to reject whitespace-only strings
+ * @property {string | null} [defaultValue] - Default value when input is empty
+ * @property {Record<Locale, TextMessages>} [i18n] - Custom error messages for different locales
+ */
+type TextOptions<IsRequired extends boolean = true> = {
+    minLength?: number;
+    maxLength?: number;
+    startsWith?: string;
+    endsWith?: string;
+    includes?: string;
+    excludes?: string | string[];
+    regex?: RegExp;
+    trimMode?: "trim" | "trimStart" | "trimEnd" | "none";
+    casing?: "upper" | "lower" | "title" | "none";
+    transform?: (value: string) => string;
+    notEmpty?: boolean;
+    defaultValue?: IsRequired extends true ? string : string | null;
+    i18n?: Partial<Record<Locale, Partial<TextMessages>>>;
+};
+/**
+ * Type alias for text validation schema based on required flag
+ *
+ * @template IsRequired - Whether the field is required
+ * @typedef TextSchema
+ * @description Returns ZodString if required, ZodNullable<ZodString> if optional
+ */
+type TextSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>;
+/**
+ * Creates a Zod schema for text validation with comprehensive string processing
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ * @param {TextOptions<IsRequired>} [options] - Configuration options for text validation
+ * @returns {TextSchema<IsRequired>} Zod schema for text validation
+ *
+ * @description
+ * Creates a comprehensive text validator with length constraints, content validation,
+ * flexible trimming and casing options, and advanced transformation features.
+ *
+ * Features:
+ * - Length validation (min/max)
+ * - Content validation (startsWith, endsWith, includes, excludes)
+ * - Regular expression pattern matching
+ * - Flexible trimming options (trim, trimStart, trimEnd, none)
+ * - Case transformation (upper, lower, title, none)
+ * - Empty string vs whitespace-only validation
+ * - Custom transformation functions
+ * - Comprehensive internationalization
+ *
+ * @example
+ * ```typescript
+ * // Basic text validation (optional by default)
+ * const basicSchema = text()
+ * basicSchema.parse("Hello World") // ✓ Valid
+ * basicSchema.parse(null) // ✓ Valid (optional)
+ *
+ * // Required text
+ * const requiredSchema = text(true)
+ * requiredSchema.parse("Hello") // ✓ Valid
+ * requiredSchema.parse(null) // ✗ Invalid (required)
+ *
+ * // Length constraints
+ * const lengthSchema = text(true, { minLength: 3, maxLength: 50 })
+ * lengthSchema.parse("Hello") // ✓ Valid
+ * lengthSchema.parse("Hi") // ✗ Invalid (too short)
+ *
+ * // Content validation
+ * const contentSchema = text(true, {
+ *   startsWith: "Hello",
+ *   endsWith: "!",
+ *   includes: "World"
+ * })
+ * contentSchema.parse("Hello World!") // ✓ Valid
+ *
+ * // Case transformation
+ * const upperSchema = text(false, { casing: "upper" })
+ * upperSchema.parse("hello") // ✓ Valid (converted to "HELLO")
+ *
+ * // Trim modes
+ * const trimStartSchema = text(false, { trimMode: "trimStart" })
+ * trimStartSchema.parse("  hello  ") // ✓ Valid (result: "hello  ")
+ *
+ * // Regex validation
+ * const regexSchema = text(true, { regex: /^[a-zA-Z]+$/ })
+ * regexSchema.parse("hello") // ✓ Valid
+ * regexSchema.parse("hello123") // ✗ Invalid
+ *
+ * // Not empty (rejects whitespace-only)
+ * const notEmptySchema = text(true, { notEmpty: true })
+ * notEmptySchema.parse("hello") // ✓ Valid
+ * notEmptySchema.parse("   ") // ✗ Invalid
+ *
+ * // Optional with default
+ * const optionalSchema = text(false, { defaultValue: "default text" })
+ * ```
+ *
+ * @throws {z.ZodError} When validation fails with specific error messages
+ * @see {@link TextOptions} for all available configuration options
+ */
+declare function text<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<TextOptions<IsRequired>, 'required'>): TextSchema<IsRequired>;
+
+export { type TextMessages, type TextOptions, type TextSchema, text };

package/dist/common/text.d.ts

@@ -0,0 +1,156 @@
+import { ZodString, ZodNullable } from 'zod';
+import { L as Locale } from '../config-CABSSvAp.js';
+
+/**
+ * @fileoverview Text validator for Zod Kit
+ *
+ * Provides comprehensive text validation with length constraints, content validation,
+ * flexible trimming and casing options, and advanced transformation features.
+ *
+ * @author Ong Hoe Yuan
+ * @version 0.0.5
+ */
+
+/**
+ * Type definition for text validation error messages
+ *
+ * @interface TextMessages
+ * @property {string} [required] - Message when field is required but empty
+ * @property {string} [notEmpty] - Message when field must not be empty (whitespace-only)
+ * @property {string} [minLength] - Message when text is shorter than minimum length
+ * @property {string} [maxLength] - Message when text exceeds maximum length
+ * @property {string} [startsWith] - Message when text doesn't start with required string
+ * @property {string} [endsWith] - Message when text doesn't end with required string
+ * @property {string} [includes] - Message when text doesn't contain required string
+ * @property {string} [excludes] - Message when text contains forbidden string
+ * @property {string} [invalid] - Message when text doesn't match regex pattern
+ */
+type TextMessages = {
+    required?: string;
+    notEmpty?: string;
+    minLength?: string;
+    maxLength?: string;
+    startsWith?: string;
+    endsWith?: string;
+    includes?: string;
+    excludes?: string;
+    invalid?: string;
+};
+/**
+ * Configuration options for text validation
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ *
+ * @interface TextOptions
+ * @property {IsRequired} [required=true] - Whether the field is required
+ * @property {number} [minLength] - Minimum length of text
+ * @property {number} [maxLength] - Maximum length of text
+ * @property {string} [startsWith] - String that text must start with
+ * @property {string} [endsWith] - String that text must end with
+ * @property {string} [includes] - String that must be included in text
+ * @property {string | string[]} [excludes] - String(s) that must not be included
+ * @property {RegExp} [regex] - Regular expression pattern for validation
+ * @property {"trim" | "trimStart" | "trimEnd" | "none"} [trimMode="trim"] - Whitespace handling
+ * @property {"upper" | "lower" | "title" | "none"} [casing="none"] - Case transformation
+ * @property {Function} [transform] - Custom transformation function for text
+ * @property {boolean} [notEmpty] - Whether to reject whitespace-only strings
+ * @property {string | null} [defaultValue] - Default value when input is empty
+ * @property {Record<Locale, TextMessages>} [i18n] - Custom error messages for different locales
+ */
+type TextOptions<IsRequired extends boolean = true> = {
+    minLength?: number;
+    maxLength?: number;
+    startsWith?: string;
+    endsWith?: string;
+    includes?: string;
+    excludes?: string | string[];
+    regex?: RegExp;
+    trimMode?: "trim" | "trimStart" | "trimEnd" | "none";
+    casing?: "upper" | "lower" | "title" | "none";
+    transform?: (value: string) => string;
+    notEmpty?: boolean;
+    defaultValue?: IsRequired extends true ? string : string | null;
+    i18n?: Partial<Record<Locale, Partial<TextMessages>>>;
+};
+/**
+ * Type alias for text validation schema based on required flag
+ *
+ * @template IsRequired - Whether the field is required
+ * @typedef TextSchema
+ * @description Returns ZodString if required, ZodNullable<ZodString> if optional
+ */
+type TextSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>;
+/**
+ * Creates a Zod schema for text validation with comprehensive string processing
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ * @param {TextOptions<IsRequired>} [options] - Configuration options for text validation
+ * @returns {TextSchema<IsRequired>} Zod schema for text validation
+ *
+ * @description
+ * Creates a comprehensive text validator with length constraints, content validation,
+ * flexible trimming and casing options, and advanced transformation features.
+ *
+ * Features:
+ * - Length validation (min/max)
+ * - Content validation (startsWith, endsWith, includes, excludes)
+ * - Regular expression pattern matching
+ * - Flexible trimming options (trim, trimStart, trimEnd, none)
+ * - Case transformation (upper, lower, title, none)
+ * - Empty string vs whitespace-only validation
+ * - Custom transformation functions
+ * - Comprehensive internationalization
+ *
+ * @example
+ * ```typescript
+ * // Basic text validation (optional by default)
+ * const basicSchema = text()
+ * basicSchema.parse("Hello World") // ✓ Valid
+ * basicSchema.parse(null) // ✓ Valid (optional)
+ *
+ * // Required text
+ * const requiredSchema = text(true)
+ * requiredSchema.parse("Hello") // ✓ Valid
+ * requiredSchema.parse(null) // ✗ Invalid (required)
+ *
+ * // Length constraints
+ * const lengthSchema = text(true, { minLength: 3, maxLength: 50 })
+ * lengthSchema.parse("Hello") // ✓ Valid
+ * lengthSchema.parse("Hi") // ✗ Invalid (too short)
+ *
+ * // Content validation
+ * const contentSchema = text(true, {
+ *   startsWith: "Hello",
+ *   endsWith: "!",
+ *   includes: "World"
+ * })
+ * contentSchema.parse("Hello World!") // ✓ Valid
+ *
+ * // Case transformation
+ * const upperSchema = text(false, { casing: "upper" })
+ * upperSchema.parse("hello") // ✓ Valid (converted to "HELLO")
+ *
+ * // Trim modes
+ * const trimStartSchema = text(false, { trimMode: "trimStart" })
+ * trimStartSchema.parse("  hello  ") // ✓ Valid (result: "hello  ")
+ *
+ * // Regex validation
+ * const regexSchema = text(true, { regex: /^[a-zA-Z]+$/ })
+ * regexSchema.parse("hello") // ✓ Valid
+ * regexSchema.parse("hello123") // ✗ Invalid
+ *
+ * // Not empty (rejects whitespace-only)
+ * const notEmptySchema = text(true, { notEmpty: true })
+ * notEmptySchema.parse("hello") // ✓ Valid
+ * notEmptySchema.parse("   ") // ✗ Invalid
+ *
+ * // Optional with default
+ * const optionalSchema = text(false, { defaultValue: "default text" })
+ * ```
+ *
+ * @throws {z.ZodError} When validation fails with specific error messages
+ * @see {@link TextOptions} for all available configuration options
+ */
+declare function text<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<TextOptions<IsRequired>, 'required'>): TextSchema<IsRequired>;
+
+export { type TextMessages, type TextOptions, type TextSchema, text };

package/dist/common/text.js

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

package/dist/common/time.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _chunkRRPXIRTQcjs = require('../chunk-RRPXIRTQ.cjs');
+require('../chunk-UCOXAZJF.cjs');
+
+
+
+
+
+
+exports.TIME_PATTERNS = _chunkRRPXIRTQcjs.TIME_PATTERNS; exports.normalizeTime = _chunkRRPXIRTQcjs.normalizeTime; exports.parseTimeToMinutes = _chunkRRPXIRTQcjs.parseTimeToMinutes; exports.time = _chunkRRPXIRTQcjs.time; exports.validateTimeFormat = _chunkRRPXIRTQcjs.validateTimeFormat;