@hy_ong/zod-kit 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hy_ong/zod-kit",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "A comprehensive TypeScript library providing pre-built Zod validation schemas with full internationalization support for common data types and Taiwan-specific formats",
   "keywords": [
     "zod",

package/src/validators/common/date.ts

@@ -238,38 +238,44 @@ export function date<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
     }
 
     // Format validation
     if (val !== null && !dayjs(val, format, true).isValid()) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("format", { format }), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("format", { format }) })
+      return
     }
 
     const dateObj = dayjs(val, format)
 
     // Range checks
     if (val !== null && min !== undefined && !dateObj.isSameOrAfter(dayjs(min, format))) {
-      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 && !dateObj.isSameOrBefore(dayjs(max, format))) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("max", { max }), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("max", { max }) })
+      return
     }
 
     // String 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
         }
       }
     }
@@ -279,27 +285,31 @@ export function date<IsRequired extends boolean = false>(required?: IsRequired,
     const targetDate = dateObj.startOf('day')
 
     if (val !== null && mustBePast && !targetDate.isBefore(today)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("past"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("past") })
+      return
     }
     if (val !== null && mustBeFuture && !targetDate.isAfter(today)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("future"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("future") })
+      return
     }
     if (val !== null && mustBeToday && !targetDate.isSame(today)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("today"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("today") })
+      return
     }
     if (val !== null && mustNotBeToday && targetDate.isSame(today)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("notToday"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("notToday") })
+      return
     }
 
     // Weekday/weekend validations
     if (val !== null && weekdaysOnly && (dateObj.day() === 0 || dateObj.day() === 6)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("weekday"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("weekday") })
+      return
     }
     if (val !== null && weekendsOnly && dateObj.day() !== 0 && dateObj.day() !== 6) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("weekend"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("weekend") })
+      return
     }
-
-    return true
   })
 
   return schema as unknown as DateSchema<IsRequired>

package/src/validators/common/datetime.ts

@@ -515,25 +515,27 @@ export function datetime<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
     }
 
-    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
     }
@@ -541,32 +543,36 @@ export function datetime<IsRequired extends boolean = false>(required?: IsRequir
     // 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 {
       // DateTime format validation (only if no regex is provided)
       if (!validateDateTimeFormat(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 datetime parsing and range validation if using custom regex
     if (regex) {
-      return true
+      return
     }
 
     // Parse datetime for validation
@@ -575,32 +581,38 @@ export function datetime<IsRequired extends boolean = false>(required?: IsRequir
       // Check if it's a format issue or parsing issue
       const pattern = DATETIME_PATTERNS[format]
       if (!pattern.test(val.trim())) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("format", { format }), path: [] }])
+        ctx.addIssue({ code: "custom", message: getMessage("format", { format }) })
+        return
       } else {
-        throw new z.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }])
+        ctx.addIssue({ code: "custom", message: getMessage("invalid") })
+        return
       }
     }
 
     // Hour validation
     const hour = parsed.hour()
     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 = parsed.minute()
     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
     }
 
     // DateTime range validation (min/max)
@@ -608,7 +620,8 @@ export function datetime<IsRequired extends boolean = false>(required?: IsRequir
       const minParsed = typeof min === "string" ? parseDateTimeValue(min, format, timezone) : dayjs(min)
       if (minParsed && parsed.isBefore(minParsed)) {
         const minFormatted = typeof min === "string" ? min : minParsed.format(format)
-        throw new z.ZodError([{ code: "custom", message: getMessage("min", { min: minFormatted }), path: [] }])
+        ctx.addIssue({ code: "custom", message: getMessage("min", { min: minFormatted }) })
+        return
       }
     }
 
@@ -616,7 +629,8 @@ export function datetime<IsRequired extends boolean = false>(required?: IsRequir
       const maxParsed = typeof max === "string" ? parseDateTimeValue(max, format, timezone) : dayjs(max)
       if (maxParsed && parsed.isAfter(maxParsed)) {
         const maxFormatted = typeof max === "string" ? max : maxParsed.format(format)
-        throw new z.ZodError([{ code: "custom", message: getMessage("max", { max: maxFormatted }), path: [] }])
+        ctx.addIssue({ code: "custom", message: getMessage("max", { max: maxFormatted }) })
+        return
       }
     }
 
@@ -624,33 +638,37 @@ export function datetime<IsRequired extends boolean = false>(required?: IsRequir
     const now = timezone ? dayjs().tz(timezone) : dayjs()
 
     if (mustBePast && !parsed.isBefore(now)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("past"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("past") })
+      return
     }
 
     if (mustBeFuture && !parsed.isAfter(now)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("future"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("future") })
+      return
     }
 
     if (mustBeToday && !parsed.isSame(now, "day")) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("today"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("today") })
+      return
     }
 
     if (mustNotBeToday && parsed.isSame(now, "day")) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("notToday"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("notToday") })
+      return
     }
 
     // Weekday validations
     const dayOfWeek = parsed.day() // 0 = Sunday, 1 = Monday, ..., 6 = Saturday
 
     if (weekdaysOnly && (dayOfWeek === 0 || dayOfWeek === 6)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("weekday"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("weekday") })
+      return
     }
 
     if (weekendsOnly && dayOfWeek !== 0 && dayOfWeek !== 6) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("weekend"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("weekend") })
+      return
     }
-
-    return true
   })
 
   return schema as unknown as DateTimeSchema<IsRequired>

package/src/validators/common/email.ts

@@ -209,37 +209,61 @@ export function email<IsRequired extends boolean = false>(required?: IsRequired,
     z.union([z.string().email(), z.null()])
   )
 
-  const schema = baseSchema.refine((val) => {
+  const schema = baseSchema.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
 
     // Invalid email check
     if (typeof val !== "string") {
-      throw new z.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }])
+      ctx.addIssue({
+        code: "custom",
+        message: getMessage("invalid")
+      })
+      return
     }
 
     // Length checks
     if (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 (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
     }
 
     // Content checks
     if (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 (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("includes", { includes: exclude }), path: [] }])
+          ctx.addIssue({
+            code: "custom",
+            message: getMessage("includes", { includes: exclude })
+          })
+          return
         }
       }
     }
@@ -247,7 +271,11 @@ export function email<IsRequired extends boolean = false>(required?: IsRequired,
     // Extract domain from email
     const emailDomain = val.split("@")[1]?.toLowerCase()
     if (!emailDomain) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }])
+      ctx.addIssue({
+        code: "custom",
+        message: getMessage("invalid")
+      })
+      return
     }
 
     // Business email check (should come before domain validation)
@@ -260,7 +288,11 @@ export function email<IsRequired extends boolean = false>(required?: IsRequired,
       })
 
       if (isFreeProvider) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("businessOnly"), path: [] }])
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("businessOnly")
+        })
+        return
       }
     }
 
@@ -275,7 +307,11 @@ export function email<IsRequired extends boolean = false>(required?: IsRequired,
       })
 
       if (isBlacklisted) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("domainBlacklist", { domain: emailDomain }), path: [] }])
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("domainBlacklist", { domain: emailDomain })
+        })
+        return
       }
     }
 
@@ -291,7 +327,11 @@ export function email<IsRequired extends boolean = false>(required?: IsRequired,
       })
 
       if (!isAllowed) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("domain", { domain: Array.isArray(domain) ? domain.join(", ") : domain }), path: [] }])
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("domain", { domain: Array.isArray(domain) ? domain.join(", ") : domain })
+        })
+        return
       }
     }
 
@@ -305,11 +345,13 @@ export function email<IsRequired extends boolean = false>(required?: IsRequired,
       })
 
       if (isDisposable) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("noDisposable"), path: [] }])
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("noDisposable")
+        })
+        return
       }
     }
-
-    return true
   })
 
   return schema as unknown as EmailSchema<IsRequired>

package/src/validators/common/id.ts

@@ -369,34 +369,37 @@ export function id<IsRequired extends boolean = false, Type extends IdType | und
   // Create base schema based on type
   if (isNumericType) {
     // Use z.any() to avoid Zod's built-in type checking, then validate manually
-    const numericSchema = z.preprocess(preprocessNumericFn, z.any()).refine((val) => {
+    const numericSchema = z.preprocess(preprocessNumericFn, z.any()).superRefine((val, ctx) => {
       // Allow null for optional fields
-      if (!isRequired && val === null) return true
+      if (!isRequired && val === null) return
 
       // Required check for undefined/null/empty (empty string when required)
       if (val === undefined || (isRequired && val === null)) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("required"), path: [] }])
+        ctx.addIssue({ code: "custom", message: getMessage("required") })
+        return
       }
 
       // Numeric validation - check if it's an actual number (not NaN)
       if (typeof val !== "number" || isNaN(val)) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("numeric"), path: [] }])
+        ctx.addIssue({ code: "custom", message: getMessage("numeric") })
+        return
       }
 
       // Length checks on string representation
       const strVal = String(val)
       if (!ID_PATTERNS.numeric.test(strVal)) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("numeric"), path: [] }])
+        ctx.addIssue({ code: "custom", message: getMessage("numeric") })
+        return
       }
 
       if (minLength !== undefined && strVal.length < minLength) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("minLength", { minLength }), path: [] }])
+        ctx.addIssue({ code: "custom", message: getMessage("minLength", { minLength }) })
+        return
       }
       if (maxLength !== undefined && strVal.length > maxLength) {
-        throw new z.ZodError([{ code: "custom", message: getMessage("maxLength", { maxLength }), path: [] }])
+        ctx.addIssue({ code: "custom", message: getMessage("maxLength", { maxLength }) })
+        return
       }
-
-      return true
     })
 
     return numericSchema as unknown as IdSchema<IsRequired, Type>
@@ -406,12 +409,13 @@ export function id<IsRequired extends boolean = false, Type extends IdType | und
   const baseSchema = isRequired ? z.preprocess(preprocessStringFn, z.string()) : z.preprocess(preprocessStringFn, z.string().nullable())
 
   const schema = baseSchema
-    .refine((val) => {
-      if (val === null) return true
+    .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
       }
 
       // Create comparison value for case-insensitive checks
@@ -419,10 +423,12 @@ export function id<IsRequired extends boolean = false, Type extends IdType | und
 
       // 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
       }
 
       // Check if we have content-based validations that override format checking
@@ -431,7 +437,8 @@ export function id<IsRequired extends boolean = false, Type extends IdType | und
       // Custom regex validation (overrides ID format validation)
       if (val !== null && customRegex !== undefined) {
         if (!customRegex.test(val)) {
-          throw new z.ZodError([{ code: "custom", message: getMessage("customFormat"), path: [] }])
+          ctx.addIssue({ code: "custom", message: getMessage("customFormat") })
+          return
         }
       } else if (val !== null && !hasContentValidations) {
         // ID type validation (only if no custom regex or content validations)
@@ -442,19 +449,22 @@ export function id<IsRequired extends boolean = false, Type extends IdType | und
           isValidId = allowedTypes.some((allowedType: IdType) => validateIdType(val, allowedType))
           if (!isValidId) {
             const typeNames = allowedTypes.join(", ")
-            throw new z.ZodError([{ code: "custom", message: getMessage("invalid") + ` (allowed types: ${typeNames})`, path: [] }])
+            ctx.addIssue({ code: "custom", message: getMessage("invalid") + ` (allowed types: ${typeNames})` })
+            return
           }
         } else if (type && type !== "auto") {
           // Validate specific type
           isValidId = validateIdType(val, type)
           if (!isValidId) {
-            throw new z.ZodError([{ code: "custom", message: getMessage(type as keyof IdMessages) || getMessage("invalid"), path: [] }])
+            ctx.addIssue({ code: "custom", message: getMessage(type as keyof IdMessages) || getMessage("invalid") })
+            return
           }
         } else {
           // Auto-detection - must match at least one known pattern
           isValidId = detectIdType(val) !== null
           if (!isValidId) {
-            throw new z.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }])
+            ctx.addIssue({ code: "custom", message: getMessage("invalid") })
+            return
           }
         }
       } else if (val !== null && hasContentValidations && type && type !== "auto" && !customRegex) {
@@ -463,11 +473,13 @@ export function id<IsRequired extends boolean = false, Type extends IdType | und
           const isValidType = allowedTypes.some((allowedType: IdType) => validateIdType(val, allowedType))
           if (!isValidType) {
             const typeNames = allowedTypes.join(", ")
-            throw new z.ZodError([{ code: "custom", message: getMessage("invalid") + ` (allowed types: ${typeNames})`, path: [] }])
+            ctx.addIssue({ code: "custom", message: getMessage("invalid") + ` (allowed types: ${typeNames})` })
+            return
           }
         } else {
           if (!validateIdType(val, type)) {
-            throw new z.ZodError([{ code: "custom", message: getMessage(type as keyof IdMessages) || getMessage("invalid"), path: [] }])
+            ctx.addIssue({ code: "custom", message: getMessage(type as keyof IdMessages) || getMessage("invalid") })
+            return
           }
         }
       }
@@ -478,25 +490,27 @@ export function id<IsRequired extends boolean = false, Type extends IdType | und
       const searchIncludes = !caseSensitive && includes ? includes.toLowerCase() : includes
 
       if (val !== null && startsWith !== undefined && !comparisonVal.startsWith(searchStartsWith!)) {
-        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 && !comparisonVal.endsWith(searchEndsWith!)) {
-        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 && !comparisonVal.includes(searchIncludes!)) {
-        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) {
           const searchExclude = !caseSensitive ? exclude.toLowerCase() : exclude
           if (comparisonVal.includes(searchExclude)) {
-            throw new z.ZodError([{ code: "custom", message: getMessage("excludes", { excludes: exclude }), path: [] }])
+            ctx.addIssue({ code: "custom", message: getMessage("excludes", { excludes: exclude }) })
+            return
           }
         }
       }
-
-      return true
     })
     .transform((val) => {
       if (val === null) return val