@hy_ong/zod-kit 0.1.7 → 0.1.9

package/dist/index.cjs

@@ -2620,11 +2620,7 @@ function twMobile(required, options) {
     }
     if (val === null) return;
     if (!isRequired && val === "") return;
-    if (whitelist && whitelist.length > 0) {
-      if (whitelist.includes(val)) {
-        return;
-      }
-      ctx.addIssue({ code: "custom", message: getMessage("notInWhitelist") });
+    if (whitelist && whitelist.length > 0 && whitelist.includes(val)) {
       return;
     }
     if (!validateTaiwanMobile(val)) {
@@ -3425,11 +3421,7 @@ function twTel(required, options) {
     }
     if (val === null) return;
     if (!isRequired && val === "") return;
-    if (whitelist && whitelist.length > 0) {
-      if (whitelist.includes(val)) {
-        return;
-      }
-      ctx.addIssue({ code: "custom", message: getMessage("notInWhitelist") });
+    if (whitelist && whitelist.length > 0 && whitelist.includes(val)) {
       return;
     }
     if (!validateTaiwanTel(val)) {
@@ -3547,11 +3539,7 @@ function twFax(required, options) {
     }
     if (val === null) return;
     if (!isRequired && val === "") return;
-    if (whitelist && whitelist.length > 0) {
-      if (whitelist.includes(val)) {
-        return;
-      }
-      ctx.addIssue({ code: "custom", message: getMessage("notInWhitelist") });
+    if (whitelist && whitelist.length > 0 && whitelist.includes(val)) {
       return;
     }
     if (!validateTaiwanFax(val)) {

package/dist/index.js

@@ -2542,11 +2542,7 @@ function twMobile(required, options) {
     }
     if (val === null) return;
     if (!isRequired && val === "") return;
-    if (whitelist && whitelist.length > 0) {
-      if (whitelist.includes(val)) {
-        return;
-      }
-      ctx.addIssue({ code: "custom", message: getMessage("notInWhitelist") });
+    if (whitelist && whitelist.length > 0 && whitelist.includes(val)) {
       return;
     }
     if (!validateTaiwanMobile(val)) {
@@ -3347,11 +3343,7 @@ function twTel(required, options) {
     }
     if (val === null) return;
     if (!isRequired && val === "") return;
-    if (whitelist && whitelist.length > 0) {
-      if (whitelist.includes(val)) {
-        return;
-      }
-      ctx.addIssue({ code: "custom", message: getMessage("notInWhitelist") });
+    if (whitelist && whitelist.length > 0 && whitelist.includes(val)) {
       return;
     }
     if (!validateTaiwanTel(val)) {
@@ -3469,11 +3461,7 @@ function twFax(required, options) {
     }
     if (val === null) return;
     if (!isRequired && val === "") return;
-    if (whitelist && whitelist.length > 0) {
-      if (whitelist.includes(val)) {
-        return;
-      }
-      ctx.addIssue({ code: "custom", message: getMessage("notInWhitelist") });
+    if (whitelist && whitelist.length > 0 && whitelist.includes(val)) {
       return;
     }
     if (!validateTaiwanFax(val)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hy_ong/zod-kit",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "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/taiwan/fax.ts

@@ -323,17 +323,12 @@ export function twFax<IsRequired extends boolean = false>(required?: IsRequired,
     if (val === null) return
     if (!isRequired && val === "") return
 
-    // Allowlist check (if an allowlist is provided, only allow values in the allowlist)
-    if (whitelist && whitelist.length > 0) {
-      if (whitelist.includes(val)) {
-        return
-      }
-      // If not in the allowlist, reject regardless of format
-      ctx.addIssue({ code: "custom", message: getMessage("notInWhitelist") })
+    // Allowlist check (if in allowlist, accept regardless of format)
+    if (whitelist && whitelist.length > 0 && whitelist.includes(val)) {
       return
     }
 
-    // Taiwan fax format validation (only if no allowlist or allowlist is empty)
+    // Taiwan fax format validation
     if (!validateTaiwanFax(val)) {
       ctx.addIssue({ code: "custom", message: getMessage("invalid") })
       return

package/src/validators/taiwan/mobile.ts

@@ -214,17 +214,12 @@ export function twMobile<IsRequired extends boolean = false>(required?: IsRequir
     if (val === null) return
     if (!isRequired && val === "") return
 
-    // Allowlist check (if an allowlist is provided, only allow values in the allowlist)
-    if (whitelist && whitelist.length > 0) {
-      if (whitelist.includes(val)) {
-        return
-      }
-      // If not in the allowlist, reject regardless of format
-      ctx.addIssue({ code: "custom", message: getMessage("notInWhitelist") })
+    // Allowlist check (if in allowlist, accept regardless of format)
+    if (whitelist && whitelist.length > 0 && whitelist.includes(val)) {
       return
     }
 
-    // Taiwan mobile phone format validation (only if no allowlist or allowlist is empty)
+    // Taiwan mobile phone format validation
     if (!validateTaiwanMobile(val)) {
       ctx.addIssue({ code: "custom", message: getMessage("invalid") })
       return

package/src/validators/taiwan/tel.ts

@@ -326,17 +326,12 @@ export function twTel<IsRequired extends boolean = false>(required?: IsRequired,
     if (val === null) return
     if (!isRequired && val === "") return
 
-    // Allowlist check (if an allowlist is provided, only allow values in the allowlist)
-    if (whitelist && whitelist.length > 0) {
-      if (whitelist.includes(val)) {
-        return
-      }
-      // If not in the allowlist, reject regardless of format
-      ctx.addIssue({ code: "custom", message: getMessage("notInWhitelist") })
+    // Allowlist check (if in allowlist, accept regardless of format)
+    if (whitelist && whitelist.length > 0 && whitelist.includes(val)) {
       return
     }
 
-    // Taiwan telephone format validation (only if no allowlist or allowlist is empty)
+    // Taiwan telephone format validation
     if (!validateTaiwanTel(val)) {
       ctx.addIssue({ code: "custom", message: getMessage("invalid") })
       return

package/tests/taiwan/fax.test.ts

@@ -102,18 +102,29 @@ describe("Taiwan twFax(true) validator", () => {
       expect(schema.parse("emergency-fax")).toBe("emergency-fax")
       expect(schema.parse("0912345678")).toBe("0912345678") // Mobile number but in allowlist
 
-      // Valid fax numbers not in the allowlist should be rejected
-      expect(() => schema.parse("0223456789")).toThrow("Not in allowed fax list")
-      expect(() => schema.parse("0711111111")).toThrow("Not in allowed fax list")
+      // Valid fax numbers not in the allowlist should still be accepted
+      expect(schema.parse("0223456789")).toBe("0223456789") // Valid format, not in whitelist
+      expect(schema.parse("072345678")).toBe("072345678") // Valid format, not in whitelist
+
+      // Invalid fax numbers not in the allowlist should be rejected
+      expect(() => schema.parse("invalid-fax")).toThrow("Invalid Taiwan fax format")
     })
 
-    it("should reject values not in whitelist when whitelist is provided", () => {
+    it("should accept both whitelist values and valid fax numbers", () => {
       const schema = twFax(true, {
         whitelist: ["allowed-value", "0223456789"],
       })
 
-      expect(() => schema.parse("0312345678")).toThrow("Not in allowed fax list")
-      expect(() => schema.parse("invalid-value")).toThrow("Not in allowed fax list")
+      // In whitelist
+      expect(schema.parse("allowed-value")).toBe("allowed-value")
+      expect(schema.parse("0223456789")).toBe("0223456789")
+
+      // Not in whitelist but valid format
+      expect(schema.parse("0312345678")).toBe("0312345678")
+      expect(schema.parse("072345678")).toBe("072345678")
+
+      // Not in whitelist and invalid format
+      expect(() => schema.parse("invalid-value")).toThrow("Invalid Taiwan fax format")
     })
 
     it("should work with empty whitelist", () => {
@@ -168,7 +179,7 @@ describe("Taiwan twFax(true) validator", () => {
       expect(schema.parse("")).toBe(null)
       expect(schema.parse("custom-value")).toBe("custom-value")
       expect(schema.parse("0223456789")).toBe("0223456789")
-      expect(() => schema.parse("0312345678")).toThrow("Not in allowed fax list")
+      expect(schema.parse("0312345678")).toBe("0312345678") // Valid format, not in whitelist
     })
   })
 
@@ -198,7 +209,8 @@ describe("Taiwan twFax(true) validator", () => {
       })
 
       expect(schema.parse("customvalue")).toBe("customvalue")
-      expect(() => schema.parse("03-123-4567")).toThrow("Not in allowed fax list")
+      expect(schema.parse("03-123-4567")).toBe("031234567") // Valid format after transform
+      expect(schema.parse("02-2345-6789")).toBe("0223456789") // In whitelist after transform
     })
   })
 
@@ -268,16 +280,20 @@ describe("Taiwan twFax(true) validator", () => {
       expect(() => schema.parse("0912345678")).toThrow("無效的傳真號碼格式")
     })
 
-    it("should support whitelist error messages", () => {
+    it("should support whitelist with valid format fallback", () => {
       setLocale("en")
       const schema = twFax(true, {
-        whitelist: ["0223456789"],
+        whitelist: ["special-fax"],
       })
 
-      expect(() => schema.parse("0312345678")).toThrow("Not in allowed fax list")
+      // In whitelist
+      expect(schema.parse("special-fax")).toBe("special-fax")
 
-      setLocale("zh-TW")
-      expect(() => schema.parse("0312345678")).toThrow("不在允許的傳真號碼清單中")
+      // Not in whitelist but valid format - should pass
+      expect(schema.parse("0223456789")).toBe("0223456789")
+
+      // Not in whitelist and invalid format - should fail
+      expect(() => schema.parse("invalid")).toThrow("Invalid Taiwan fax format")
     })
 
     it("should support custom i18n messages", () => {
@@ -305,24 +321,24 @@ describe("Taiwan twFax(true) validator", () => {
       expect(() => schema.parse("0912345678")).toThrow("傳真號碼格式錯誤")
     })
 
-    it("should support custom whitelist messages", () => {
+    it("should support custom i18n messages for invalid format", () => {
       const schema = twFax(true, {
-        whitelist: ["0223456789"],
+        whitelist: ["special-value"],
         i18n: {
           en: {
-            notInWhitelist: "This fax number is not allowed",
+            invalid: "This fax format is not valid",
           },
           "zh-TW": {
-            notInWhitelist: "此傳真號碼不被允許",
+            invalid: "此傳真格式無效",
           },
         },
       })
 
       setLocale("en")
-      expect(() => schema.parse("0312345678")).toThrow("This fax number is not allowed")
+      expect(() => schema.parse("invalid-format")).toThrow("This fax format is not valid")
 
       setLocale("zh-TW")
-      expect(() => schema.parse("0312345678")).toThrow("此傳真號碼不被允許")
+      expect(() => schema.parse("invalid-format")).toThrow("此傳真格式無效")
     })
   })
 
@@ -420,15 +436,18 @@ describe("Taiwan twFax(true) validator", () => {
     it("should work with complex whitelist scenarios", () => {
       const schema = twFax(false, { whitelist: ["0223456789", "emergency", "custom-fax-123", ""] })
 
-      // Allowlist scenarios
+      // In whitelist
       expect(schema.parse("0223456789")).toBe("0223456789")
       expect(schema.parse("emergency")).toBe("emergency")
       expect(schema.parse("custom-fax-123")).toBe("custom-fax-123")
       expect(schema.parse("")).toBe("")
 
-      // Not in the allowlist
-      expect(() => schema.parse("0312345678")).toThrow("Not in allowed fax list")
-      expect(() => schema.parse("other-value")).toThrow("Not in allowed fax list")
+      // Not in whitelist but valid format
+      expect(schema.parse("0312345678")).toBe("0312345678")
+      expect(schema.parse("072345678")).toBe("072345678")
+
+      // Not in whitelist and invalid format
+      expect(() => schema.parse("other-value")).toThrow("Invalid Taiwan fax format")
     })
 
     it("should handle boundary cases for area codes", () => {

package/tests/taiwan/mobile.test.ts

@@ -54,18 +54,29 @@ describe("Taiwan twMobile(true) validator", () => {
       expect(schema.parse("emergency-contact")).toBe("emergency-contact")
       expect(schema.parse("0801234567")).toBe("0801234567") // Invalid mobile but in allowlist
 
-      // Valid mobile phones not in the allowlist should be rejected
-      expect(() => schema.parse("0901234567")).toThrow("Not in allowed mobile phone list")
-      expect(() => schema.parse("0801111111")).toThrow("Not in allowed mobile phone list")
+      // Valid mobile phones not in the allowlist should still be accepted
+      expect(schema.parse("0901234567")).toBe("0901234567") // Valid format, not in whitelist
+      expect(schema.parse("0911234567")).toBe("0911234567") // Valid format, not in whitelist
+
+      // Invalid mobile numbers not in the allowlist should be rejected
+      expect(() => schema.parse("invalid-phone")).toThrow("Invalid Taiwan mobile phone format")
     })
 
-    it("should reject values not in whitelist when whitelist is provided", () => {
+    it("should accept both whitelist values and valid mobile numbers", () => {
       const schema = twMobile(true, {
         whitelist: ["allowed-value", "0901234567"],
       })
 
-      expect(() => schema.parse("0911234567")).toThrow("Not in allowed mobile phone list")
-      expect(() => schema.parse("invalid-value")).toThrow("Not in allowed mobile phone list")
+      // In whitelist
+      expect(schema.parse("allowed-value")).toBe("allowed-value")
+      expect(schema.parse("0901234567")).toBe("0901234567")
+
+      // Not in whitelist but valid format
+      expect(schema.parse("0911234567")).toBe("0911234567")
+      expect(schema.parse("0921234567")).toBe("0921234567")
+
+      // Not in whitelist and invalid format
+      expect(() => schema.parse("invalid-value")).toThrow("Invalid Taiwan mobile phone format")
     })
 
     it("should work with empty whitelist", () => {
@@ -120,7 +131,7 @@ describe("Taiwan twMobile(true) validator", () => {
       expect(schema.parse("")).toBe(null)
       expect(schema.parse("custom-value")).toBe("custom-value")
       expect(schema.parse("0901234567")).toBe("0901234567")
-      expect(() => schema.parse("0911234567")).toThrow("Not in allowed mobile phone list")
+      expect(schema.parse("0911234567")).toBe("0911234567") // Valid format, not in whitelist
     })
   })
 
@@ -157,7 +168,7 @@ describe("Taiwan twMobile(true) validator", () => {
       })
 
       expect(whitelistSchema.parse("customvalue")).toBe("customvalue")
-      expect(() => whitelistSchema.parse("091-123-4567")).toThrow("Not in allowed mobile phone list")
+      expect(whitelistSchema.parse("091-123-4567")).toBe("0911234567") // Valid format after transform
     })
   })
 
@@ -221,16 +232,17 @@ describe("Taiwan twMobile(true) validator", () => {
       expect(() => schema.parse("0801234567")).toThrow("無效的手機號碼格式")
     })
 
-    it("should support whitelist error messages", () => {
+    it("should accept valid format even when not in whitelist", () => {
       setLocale("en")
       const schema = twMobile(true, {
         whitelist: ["0901234567"],
       })
 
-      expect(() => schema.parse("0911234567")).toThrow("Not in allowed mobile phone list")
+      // Valid format, not in whitelist - should pass
+      expect(schema.parse("0911234567")).toBe("0911234567")
 
       setLocale("zh-TW")
-      expect(() => schema.parse("0911234567")).toThrow("不在允許的手機號碼清單中")
+      expect(schema.parse("0921234567")).toBe("0921234567")
     })
 
     it("should support custom i18n messages", () => {
@@ -258,24 +270,24 @@ describe("Taiwan twMobile(true) validator", () => {
       expect(() => schema.parse("0801234567")).toThrow("手機號碼格式錯誤")
     })
 
-    it("should support custom whitelist messages", () => {
+    it("should support custom invalid messages", () => {
       const schema = twMobile(true, {
         whitelist: ["0901234567"],
         i18n: {
           en: {
-            notInWhitelist: "This mobile phone number is not allowed",
+            invalid: "This mobile phone format is not valid",
           },
           "zh-TW": {
-            notInWhitelist: "此手機號碼不被允許",
+            invalid: "此手機號碼格式無效",
           },
         },
       })
 
       setLocale("en")
-      expect(() => schema.parse("0911234567")).toThrow("This mobile phone number is not allowed")
+      expect(() => schema.parse("0801234567")).toThrow("This mobile phone format is not valid")
 
       setLocale("zh-TW")
-      expect(() => schema.parse("0911234567")).toThrow("此手機號碼不被允許")
+      expect(() => schema.parse("0801234567")).toThrow("此手機號碼格式無效")
     })
   })
 
@@ -356,9 +368,11 @@ describe("Taiwan twMobile(true) validator", () => {
       expect(schema.parse("custom-contact-123")).toBe("custom-contact-123")
       expect(schema.parse("")).toBe("")
 
-      // Not in the allowlist
-      expect(() => schema.parse("0911234567")).toThrow("Not in allowed mobile phone list")
-      expect(() => schema.parse("other-value")).toThrow("Not in allowed mobile phone list")
+      // Valid format but not in the allowlist - should pass
+      expect(schema.parse("0911234567")).toBe("0911234567")
+
+      // Invalid format and not in allowlist - should fail
+      expect(() => schema.parse("other-value")).toThrow("Invalid Taiwan mobile phone format")
     })
   })
 })

package/tests/taiwan/tel.test.ts

@@ -103,18 +103,29 @@ describe("Taiwan twTel(true) validator", () => {
       expect(schema.parse("emergency-line")).toBe("emergency-line")
       expect(schema.parse("0912345678")).toBe("0912345678") // Mobile number but in allowlist
 
-      // Valid telephone numbers not in the allowlist should be rejected
-      expect(() => schema.parse("0212345678")).toThrow("Not in allowed telephone list")
-      expect(() => schema.parse("0711111111")).toThrow("Not in allowed telephone list")
+      // Valid telephone numbers not in the allowlist should still be accepted
+      expect(schema.parse("0223456789")).toBe("0223456789") // Valid format, not in whitelist
+      expect(schema.parse("072345678")).toBe("072345678") // Valid format, not in whitelist
+
+      // Invalid telephone numbers not in the allowlist should be rejected
+      expect(() => schema.parse("invalid-phone")).toThrow("Invalid Taiwan telephone format")
     })
 
-    it("should reject values not in whitelist when whitelist is provided", () => {
+    it("should accept both whitelist values and valid telephone numbers", () => {
       const schema = twTel(true, {
         whitelist: ["allowed-value", "0223456789"],
       })
 
-      expect(() => schema.parse("0312345678")).toThrow("Not in allowed telephone list")
-      expect(() => schema.parse("invalid-value")).toThrow("Not in allowed telephone list")
+      // In whitelist
+      expect(schema.parse("allowed-value")).toBe("allowed-value")
+      expect(schema.parse("0223456789")).toBe("0223456789")
+
+      // Not in whitelist but valid format
+      expect(schema.parse("0312345678")).toBe("0312345678")
+      expect(schema.parse("072345678")).toBe("072345678")
+
+      // Not in whitelist and invalid format
+      expect(() => schema.parse("invalid-value")).toThrow("Invalid Taiwan telephone format")
     })
 
     it("should work with empty whitelist", () => {
@@ -169,7 +180,7 @@ describe("Taiwan twTel(true) validator", () => {
       expect(schema.parse("")).toBe(null)
       expect(schema.parse("custom-value")).toBe("custom-value")
       expect(schema.parse("0223456789")).toBe("0223456789")
-      expect(() => schema.parse("0312345678")).toThrow("Not in allowed telephone list")
+      expect(schema.parse("0312345678")).toBe("0312345678") // Valid format, not in whitelist
     })
   })
 
@@ -199,7 +210,8 @@ describe("Taiwan twTel(true) validator", () => {
       })
 
       expect(schema.parse("customvalue")).toBe("customvalue")
-      expect(() => schema.parse("03-123-4567")).toThrow("Not in allowed telephone list")
+      expect(schema.parse("03-123-4567")).toBe("031234567") // Valid format after transform
+      expect(schema.parse("02-2345-6789")).toBe("0223456789") // In whitelist after transform
     })
   })
 
@@ -273,16 +285,20 @@ describe("Taiwan twTel(true) validator", () => {
       expect(() => schema.parse("0912345678")).toThrow("無效的市話號碼格式")
     })
 
-    it("should support whitelist error messages", () => {
+    it("should support whitelist with valid format fallback", () => {
       setLocale("en")
       const schema = twTel(true, {
-        whitelist: ["0212345678"],
+        whitelist: ["special-number"],
       })
 
-      expect(() => schema.parse("0312345678")).toThrow("Not in allowed telephone list")
+      // In whitelist
+      expect(schema.parse("special-number")).toBe("special-number")
 
-      setLocale("zh-TW")
-      expect(() => schema.parse("0312345678")).toThrow("不在允許的市話號碼清單中")
+      // Not in whitelist but valid format - should pass
+      expect(schema.parse("0223456789")).toBe("0223456789")
+
+      // Not in whitelist and invalid format - should fail
+      expect(() => schema.parse("invalid")).toThrow("Invalid Taiwan telephone format")
     })
 
     it("should support custom i18n messages", () => {
@@ -310,24 +326,24 @@ describe("Taiwan twTel(true) validator", () => {
       expect(() => schema.parse("0912345678")).toThrow("電話號碼格式錯誤")
     })
 
-    it("should support custom whitelist messages", () => {
+    it("should support custom i18n messages for invalid format", () => {
       const schema = twTel(true, {
-        whitelist: ["0212345678"],
+        whitelist: ["special-value"],
         i18n: {
           en: {
-            notInWhitelist: "This telephone number is not allowed",
+            invalid: "This telephone format is not valid",
           },
           "zh-TW": {
-            notInWhitelist: "此電話號碼不被允許",
+            invalid: "此電話格式無效",
           },
         },
       })
 
       setLocale("en")
-      expect(() => schema.parse("0312345678")).toThrow("This telephone number is not allowed")
+      expect(() => schema.parse("invalid-format")).toThrow("This telephone format is not valid")
 
       setLocale("zh-TW")
-      expect(() => schema.parse("0312345678")).toThrow("此電話號碼不被允許")
+      expect(() => schema.parse("invalid-format")).toThrow("此電話格式無效")
     })
   })
 
@@ -425,15 +441,18 @@ describe("Taiwan twTel(true) validator", () => {
     it("should work with complex whitelist scenarios", () => {
       const schema = twTel(false, { whitelist: ["0223456789", "emergency", "custom-contact-123", ""] })
 
-      // Allowlist scenarios
+      // In whitelist
       expect(schema.parse("0223456789")).toBe("0223456789")
       expect(schema.parse("emergency")).toBe("emergency")
       expect(schema.parse("custom-contact-123")).toBe("custom-contact-123")
       expect(schema.parse("")).toBe("")
 
-      // Not in the allowlist
-      expect(() => schema.parse("0312345678")).toThrow("Not in allowed telephone list")
-      expect(() => schema.parse("other-value")).toThrow("Not in allowed telephone list")
+      // Not in whitelist but valid format
+      expect(schema.parse("0312345678")).toBe("0312345678")
+      expect(schema.parse("072345678")).toBe("072345678")
+
+      // Not in whitelist and invalid format
+      expect(() => schema.parse("other-value")).toThrow("Invalid Taiwan telephone format")
     })
 
     it("should handle boundary cases for area codes", () => {