@hy_ong/zod-kit 0.1.2 → 0.1.3

package/src/validators/common/number.ts

@@ -98,6 +98,7 @@ export type NumberSchema<IsRequired extends boolean> = IsRequired extends true ?
  * 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
  *
@@ -165,25 +166,10 @@ export type NumberSchema<IsRequired extends boolean> = IsRequired extends true ?
  * @throws {z.ZodError} When validation fails with specific error messages
  * @see {@link NumberOptions} for all available configuration options
  */
-export function number<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<NumberOptions<IsRequired>, 'required'>): NumberSchema<IsRequired> {
-  const {
-    min,
-    max,
-    defaultValue,
-    type = "both",
-    positive,
-    negative,
-    nonNegative,
-    nonPositive,
-    multipleOf,
-    precision,
-    finite = true,
-    transform,
-    parseCommas = false,
-    i18n,
-  } = options ?? {}
+export function number<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<NumberOptions<IsRequired>, "required">): NumberSchema<IsRequired> {
+  const { min, max, defaultValue, type = "both", positive, negative, nonNegative, nonPositive, multipleOf, precision, finite = true, transform, parseCommas = false, i18n } = options ?? {}
 
-  const isRequired = required ?? false as IsRequired
+  const isRequired = required ?? (false as IsRequired)
 
   // Helper function to get custom message or fallback to default i18n
   const getMessage = (key: keyof NumberMessages, params?: Record<string, any>) => {
@@ -243,79 +229,130 @@ export function number<IsRequired extends boolean = false>(required?: IsRequired
       },
       z.union([z.number(), z.null(), z.nan(), z.custom<number>((val) => val === Infinity || val === -Infinity)])
     )
-    .refine((val) => {
+    .superRefine((val, ctx) => {
       // Required check first
       if (isRequired && val === null) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("required"), path: [] }])
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("required"),
+        })
+        return
       }
 
-      if (val === null) return true
+      if (val === null) return
 
       // Type validation for invalid inputs (NaN)
-      if (typeof val === "number" && isNaN(val)) {
+      if (isNaN(val)) {
         if (type === "integer") {
-          throw new z.ZodError([{ code: "custom", message: getMessage("integer"), path: [] }])
+          ctx.addIssue({
+            code: "custom",
+            message: getMessage("integer"),
+          })
         } else if (type === "float") {
-          throw new z.ZodError([{ code: "custom", message: getMessage("float"), path: [] }])
+          ctx.addIssue({
+            code: "custom",
+            message: getMessage("float"),
+          })
         } else {
-          throw new z.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }])
+          ctx.addIssue({
+            code: "custom",
+            message: getMessage("invalid"),
+          })
         }
-      }
-
-      // Invalid number check for non-numbers
-      if (typeof val !== "number") {
-        throw new z.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }])
+        return
       }
 
       // Finite check
       if (finite && !Number.isFinite(val)) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("finite"), path: [] }])
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("finite"),
+        })
+        return
       }
 
       // Type validation for valid numbers
       if (type === "integer" && !Number.isInteger(val)) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("integer"), path: [] }])
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("integer"),
+        })
+        return
       }
       if (type === "float" && Number.isInteger(val)) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("float"), path: [] }])
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("float"),
+        })
+        return
       }
 
       // Sign checks (more specific, should come first)
       if (positive && val <= 0) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("positive"), path: [] }])
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("positive"),
+        })
+        return
       }
       if (negative && val >= 0) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("negative"), path: [] }])
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("negative"),
+        })
+        return
       }
       if (nonNegative && val < 0) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("nonNegative"), path: [] }])
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("nonNegative"),
+        })
+        return
       }
       if (nonPositive && val > 0) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("nonPositive"), path: [] }])
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("nonPositive"),
+        })
+        return
       }
 
       // Range checks
       if (min !== undefined && val < min) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("min", { min }), path: [] }])
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("min", { min }),
+        })
+        return
       }
       if (max !== undefined && val > max) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("max", { max }), path: [] }])
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("max", { max }),
+        })
+        return
       }
 
       // Multiple of check
       if (multipleOf !== undefined && val % multipleOf !== 0) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("multipleOf", { multipleOf }), path: [] }])
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("multipleOf", { multipleOf }),
+        })
+        return
       }
 
       // 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: [] }])
+          ctx.addIssue({
+            code: "custom",
+            message: getMessage("precision", { precision }),
+          })
+          return
         }
       }
-
-      return true
     })
 
   return schema as unknown as NumberSchema<IsRequired>

package/src/validators/common/password.ts

@@ -320,45 +320,55 @@ export function password<IsRequired extends boolean = false>(required?: IsRequir
 
   const baseSchema = isRequired ? z.preprocess(preprocessFn, z.string()) : z.preprocess(preprocessFn, z.string().nullable())
 
-  const schema = baseSchema.refine((val) => {
-    if (val === null) return true
+  const schema = baseSchema.superRefine((val, ctx) => {
+    if (val === null) return
 
     // Required check
     if (isRequired && (val === "" || val === "null" || val === "undefined")) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("required"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("required") })
+      return
     }
 
     // Length checks
     if (val !== null && min !== undefined && val.length < min) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("min", { min }), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("min", { min }) })
+      return
     }
     if (val !== null && max !== undefined && val.length > max) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("max", { max }), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("max", { max }) })
+      return
     }
 
     // Character requirements
     if (val !== null && uppercase && !/[A-Z]/.test(val)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("uppercase"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("uppercase") })
+      return
     }
     if (val !== null && lowercase && !/[a-z]/.test(val)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("lowercase"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("lowercase") })
+      return
     }
     if (val !== null && digits && !/[0-9]/.test(val)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("digits"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("digits") })
+      return
     }
     if (val !== null && special && !/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(val)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("special"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("special") })
+      return
     }
 
     // Advanced security checks
     if (val !== null && noRepeating && /(.)\1{2,}/.test(val)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("noRepeating"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("noRepeating") })
+      return
     }
     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: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("noSequential") })
+      return
     }
     if (val !== null && noCommonWords && COMMON_PASSWORDS.some((common) => val.toLowerCase().includes(common.toLowerCase()))) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("noCommonWords"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("noCommonWords") })
+      return
     }
     if (val !== null && minStrength) {
       const strength = calculatePasswordStrength(val)
@@ -366,27 +376,29 @@ export function password<IsRequired extends boolean = false>(required?: IsRequir
       const currentLevel = strengthLevels.indexOf(strength)
       const requiredLevel = strengthLevels.indexOf(minStrength)
       if (currentLevel < requiredLevel) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("minStrength", { minStrength }), path: [] }])
+        ctx.addIssue({ code: "custom", message: getMessage("minStrength", { minStrength }) })
+        return
       }
     }
 
     // Content checks
     if (val !== null && includes !== undefined && !val.includes(includes)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("includes", { includes }), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("includes", { includes }) })
+      return
     }
     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: [] }])
+          ctx.addIssue({ code: "custom", message: getMessage("excludes", { excludes: exclude }) })
+          return
         }
       }
     }
     if (val !== null && regex !== undefined && !regex.test(val)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("invalid", { regex }), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("invalid", { regex }) })
+      return
     }
-
-    return true
   })
 
   return schema as unknown as PasswordSchema<IsRequired>

package/src/validators/common/text.ts

@@ -223,52 +223,86 @@ export function text<IsRequired extends boolean = false>(required?: IsRequired,
 
   const baseSchema = isRequired ? z.preprocess(preprocessFn, z.string()) : z.preprocess(preprocessFn, z.string().nullable())
 
-  // Single refine with all validations for better performance
-  const schema = baseSchema.refine((val) => {
-    if (val === null) return true
+  // Single superRefine with all validations for better performance
+  const schema = baseSchema.superRefine((val, ctx) => {
+    if (val === null) return
 
     // Required check
     if (isRequired && (val === "" || val === "null" || val === "undefined")) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("required"), path: [] }])
+      ctx.addIssue({
+        code: "custom",
+        message: getMessage("required")
+      })
+      return
     }
 
     // Not empty check (different from required - checks whitespace)
     // For notEmpty, we need to check if the original string (before processing) was only whitespace
     if (notEmpty && val !== null && val.trim() === "") {
-      throw new z.ZodError([{ code: "custom", message: getMessage("notEmpty"), path: [] }])
+      ctx.addIssue({
+        code: "custom",
+        message: getMessage("notEmpty")
+      })
+      return
     }
 
     // Length checks
     if (val !== null && minLength !== undefined && val.length < minLength) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("minLength", { minLength }), path: [] }])
+      ctx.addIssue({
+        code: "custom",
+        message: getMessage("minLength", { minLength })
+      })
+      return
     }
     if (val !== null && maxLength !== undefined && val.length > maxLength) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("maxLength", { maxLength }), path: [] }])
+      ctx.addIssue({
+        code: "custom",
+        message: getMessage("maxLength", { maxLength })
+      })
+      return
     }
 
     // String content checks
     if (val !== null && startsWith !== undefined && !val.startsWith(startsWith)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("startsWith", { startsWith }), path: [] }])
+      ctx.addIssue({
+        code: "custom",
+        message: getMessage("startsWith", { startsWith })
+      })
+      return
     }
     if (val !== null && endsWith !== undefined && !val.endsWith(endsWith)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("endsWith", { endsWith }), path: [] }])
+      ctx.addIssue({
+        code: "custom",
+        message: getMessage("endsWith", { endsWith })
+      })
+      return
     }
     if (val !== null && includes !== undefined && !val.includes(includes)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("includes", { includes }), path: [] }])
+      ctx.addIssue({
+        code: "custom",
+        message: getMessage("includes", { includes })
+      })
+      return
     }
     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: [] }])
+          ctx.addIssue({
+            code: "custom",
+            message: getMessage("excludes", { excludes: exclude })
+          })
+          return
         }
       }
     }
     if (val !== null && regex !== undefined && !regex.test(val)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("invalid", { regex }), path: [] }])
+      ctx.addIssue({
+        code: "custom",
+        message: getMessage("invalid", { regex })
+      })
+      return
     }
-
-    return true
   })
 
   return schema as unknown as TextSchema<IsRequired>

package/src/validators/common/time.ts

@@ -465,25 +465,27 @@ export function time<IsRequired extends boolean = false>(required?: IsRequired,
 
   const baseSchema = isRequired ? z.preprocess(preprocessFn, z.string()) : z.preprocess(preprocessFn, z.string().nullable())
 
-  const schema = baseSchema.refine((val) => {
-    if (val === null) return true
+  const schema = baseSchema.superRefine((val, ctx) => {
+    if (val === null) return
 
     // Required check
     if (isRequired && (val === "" || val === "null" || val === "undefined")) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("required"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("required") })
+      return
     }
 
-    if (val === null) return true
-    if (!isRequired && val === "") return true
+    if (val === null) return
+    if (!isRequired && val === "") return
 
     // Whitelist check
     if (whitelist && whitelist.length > 0) {
       if (whitelist.includes(val)) {
-        return true
+        return
       }
       // If whitelistOnly is true, reject values not in whitelist
       if (whitelistOnly) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("notInWhitelist"), path: [] }])
+        ctx.addIssue({ code: "custom", message: getMessage("notInWhitelist") })
+        return
       }
       // Otherwise, continue with normal validation
     }
@@ -491,60 +493,69 @@ export function time<IsRequired extends boolean = false>(required?: IsRequired,
     // Custom regex validation (overrides format validation)
     if (regex) {
       if (!regex.test(val)) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("customRegex"), path: [] }])
+        ctx.addIssue({ code: "custom", message: getMessage("customRegex") })
+        return
       }
     } else {
       // Time format validation (only if no regex is provided)
       if (!validateTimeFormat(val, format)) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("format", { format }), path: [] }])
+        ctx.addIssue({ code: "custom", message: getMessage("format", { format }) })
+        return
       }
     }
 
     // String content checks
     if (includes && !val.includes(includes)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("includes", { includes }), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("includes", { includes }) })
+      return
     }
 
     if (excludes) {
       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: [] }])
+          ctx.addIssue({ code: "custom", message: getMessage("excludes", { excludes: exclude }) })
+          return
         }
       }
     }
 
     // Skip time parsing and range validation if using custom regex
     if (regex) {
-      return true
+      return
     }
 
     // Parse time for range validation
     const timeMinutes = parseTimeToMinutes(val, format)
     if (timeMinutes === null) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("invalid") })
+      return
     }
 
     // Hour validation
     const hour = Math.floor(timeMinutes / 60)
     if (minHour !== undefined && hour < minHour) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("hour", { minHour, maxHour: maxHour ?? 23 }), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("hour", { minHour, maxHour: maxHour ?? 23 }) })
+      return
     }
     if (maxHour !== undefined && hour > maxHour) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("hour", { minHour: minHour ?? 0, maxHour }), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("hour", { minHour: minHour ?? 0, maxHour }) })
+      return
     }
 
     // Allowed hours check
     if (allowedHours && allowedHours.length > 0) {
       if (!allowedHours.includes(hour)) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("hour", { allowedHours: allowedHours.join(", ") }), path: [] }])
+        ctx.addIssue({ code: "custom", message: getMessage("hour", { allowedHours: allowedHours.join(", ") }) })
+        return
       }
     }
 
     // Minute step validation
     const minute = timeMinutes % 60
     if (minuteStep !== undefined && minute % minuteStep !== 0) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("minute", { minuteStep }), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("minute", { minuteStep }) })
+      return
     }
 
     // Second step validation (only for formats with seconds)
@@ -554,7 +565,8 @@ export function time<IsRequired extends boolean = false>(required?: IsRequired,
       if (secondMatch) {
         const seconds = parseInt(secondMatch[1], 10)
         if (seconds % secondStep !== 0) {
-          throw new z.ZodError([{ code: "custom", message: getMessage("second", { secondStep }), path: [] }])
+          ctx.addIssue({ code: "custom", message: getMessage("second", { secondStep }) })
+          return
         }
       }
     }
@@ -563,18 +575,18 @@ export function time<IsRequired extends boolean = false>(required?: IsRequired,
     if (min) {
       const minMinutes = parseTimeToMinutes(min, format)
       if (minMinutes !== null && timeMinutes < minMinutes) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("min", { min }), path: [] }])
+        ctx.addIssue({ code: "custom", message: getMessage("min", { min }) })
+        return
       }
     }
 
     if (max) {
       const maxMinutes = parseTimeToMinutes(max, format)
       if (maxMinutes !== null && timeMinutes > maxMinutes) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("max", { max }), path: [] }])
+        ctx.addIssue({ code: "custom", message: getMessage("max", { max }) })
+        return
       }
     }
-
-    return true
   })
 
   return schema as unknown as TimeSchema<IsRequired>