@hy_ong/zod-kit 0.1.2 → 0.1.4

package/tests/taiwan/mobile.test.ts

@@ -1,12 +1,12 @@
 import { describe, it, expect, beforeEach } from "vitest"
-import { mobile, setLocale, validateTaiwanMobile } from "../../src"
+import { twMobile, setLocale, validateTaiwanMobile } from "../../src"
 
-describe("Taiwan mobile(true) validator", () => {
+describe("Taiwan twMobile(true) validator", () => {
   beforeEach(() => setLocale("en"))
 
   describe("basic functionality", () => {
     it("should validate correct Taiwan mobile phone numbers", () => {
-      const schema = mobile(true)
+      const schema = twMobile(true)
 
       // Valid Taiwan mobile phone numbers
       expect(schema.parse("0901234567")).toBe("0901234567")
@@ -22,7 +22,7 @@ describe("Taiwan mobile(true) validator", () => {
     })
 
     it("should reject invalid Taiwan mobile phone numbers", () => {
-      const schema = mobile(true)
+      const schema = twMobile(true)
 
       // Invalid formats
       expect(() => schema.parse("123456789")).toThrow("Invalid Taiwan mobile phone format") // Missing leading 09
@@ -36,7 +36,7 @@ describe("Taiwan mobile(true) validator", () => {
     })
 
     it("should handle whitespace trimming", () => {
-      const schema = mobile(true)
+      const schema = twMobile(true)
 
       expect(schema.parse("  0901234567  ")).toBe("0901234567")
       expect(schema.parse("\t0911234567\n")).toBe("0911234567")
@@ -45,7 +45,7 @@ describe("Taiwan mobile(true) validator", () => {
 
   describe("whitelist functionality", () => {
     it("should accept any string in whitelist regardless of format", () => {
-      const schema = mobile(true, {
+      const schema = twMobile(true, {
         whitelist: ["custom-phone", "emergency-contact", "0801234567"],
       })
 
@@ -60,7 +60,7 @@ describe("Taiwan mobile(true) validator", () => {
     })
 
     it("should reject values not in whitelist when whitelist is provided", () => {
-      const schema = mobile(true, {
+      const schema = twMobile(true, {
         whitelist: ["allowed-value", "0901234567"],
       })
 
@@ -69,7 +69,7 @@ describe("Taiwan mobile(true) validator", () => {
     })
 
     it("should work with empty whitelist", () => {
-      const schema = mobile(true, {
+      const schema = twMobile(true, {
         whitelist: [],
       })
 
@@ -79,7 +79,7 @@ describe("Taiwan mobile(true) validator", () => {
     })
 
     it("should prioritize whitelist over format validation", () => {
-      const schema = mobile(false, { whitelist: ["not-a-phone", "123", ""] })
+      const schema = twMobile(false, { whitelist: ["not-a-phone", "123", ""] })
 
       // These should be accepted despite being invalid mobile phone formats
       expect(schema.parse("not-a-phone")).toBe("not-a-phone")
@@ -90,7 +90,7 @@ describe("Taiwan mobile(true) validator", () => {
 
   describe("required/optional behavior", () => {
     it("should handle required=true (default)", () => {
-      const schema = mobile(true)
+      const schema = twMobile(true)
 
       expect(() => schema.parse("")).toThrow("Required")
       expect(() => schema.parse(null)).toThrow()
@@ -98,7 +98,7 @@ describe("Taiwan mobile(true) validator", () => {
     })
 
     it("should handle required=false", () => {
-      const schema = mobile(false)
+      const schema = twMobile(false)
 
       expect(schema.parse("")).toBe(null)
       expect(schema.parse(null)).toBe(null)
@@ -107,15 +107,15 @@ describe("Taiwan mobile(true) validator", () => {
     })
 
     it("should use default values", () => {
-      const requiredSchema = mobile(true, { defaultValue: "0901234567" })
-      const optionalSchema = mobile(false, { defaultValue: "0901234567" })
+      const requiredSchema = twMobile(true, { defaultValue: "0901234567" })
+      const optionalSchema = twMobile(false, { defaultValue: "0901234567" })
 
       expect(requiredSchema.parse("")).toBe("0901234567")
       expect(optionalSchema.parse("")).toBe("0901234567")
     })
 
     it("should handle whitelist with optional fields", () => {
-      const schema = mobile(false, { whitelist: ["custom-value", "0901234567"] })
+      const schema = twMobile(false, { whitelist: ["custom-value", "0901234567"] })
 
       expect(schema.parse("")).toBe(null)
       expect(schema.parse("custom-value")).toBe("custom-value")
@@ -126,7 +126,7 @@ describe("Taiwan mobile(true) validator", () => {
 
   describe("transform function", () => {
     it("should apply custom transform", () => {
-      const schema = mobile(true, {
+      const schema = twMobile(true, {
         transform: (val) => val.replace(/[-\s]/g, ""),
       })
 
@@ -135,7 +135,7 @@ describe("Taiwan mobile(true) validator", () => {
     })
 
     it("should apply transform before validation", () => {
-      const schema = mobile(true, {
+      const schema = twMobile(true, {
         transform: (val) => val.replace(/\s+/g, ""),
       })
 
@@ -145,13 +145,13 @@ describe("Taiwan mobile(true) validator", () => {
 
     it("should work with whitelist after transform", () => {
       // First test basic transform without allowlist
-      const basicSchema = mobile(true, {
+      const basicSchema = twMobile(true, {
         transform: (val) => val.replace(/[-\s]/g, ""),
       })
       expect(basicSchema.parse("090-123-4567")).toBe("0901234567")
 
       // Then test with whitelist - use simple value that transforms won't affect
-      const whitelistSchema = mobile(true, {
+      const whitelistSchema = twMobile(true, {
         transform: (val) => val.replace(/[-\s]/g, ""),
         whitelist: ["0901234567", "customvalue"],
       })
@@ -163,14 +163,14 @@ describe("Taiwan mobile(true) validator", () => {
 
   describe("input preprocessing", () => {
     it("should handle string conversion", () => {
-      const schema = mobile(true)
+      const schema = twMobile(true)
 
       // Test string conversion of numbers
       expect(() => schema.parse(901234567)).toThrow("Invalid Taiwan mobile phone format") // Invalid because missing leading 0
     })
 
     it("should trim whitespace", () => {
-      const schema = mobile(true)
+      const schema = twMobile(true)
 
       expect(schema.parse("  0901234567  ")).toBe("0901234567")
       expect(schema.parse("\t0911234567\n")).toBe("0911234567")
@@ -207,7 +207,7 @@ describe("Taiwan mobile(true) validator", () => {
   describe("i18n support", () => {
     it("should use English messages by default", () => {
       setLocale("en")
-      const schema = mobile(true)
+      const schema = twMobile(true)
 
       expect(() => schema.parse("")).toThrow("Required")
       expect(() => schema.parse("0801234567")).toThrow("Invalid Taiwan mobile phone format")
@@ -215,7 +215,7 @@ describe("Taiwan mobile(true) validator", () => {
 
     it("should use Chinese messages when locale is zh-TW", () => {
       setLocale("zh-TW")
-      const schema = mobile(true)
+      const schema = twMobile(true)
 
       expect(() => schema.parse("")).toThrow("必填")
       expect(() => schema.parse("0801234567")).toThrow("無效的手機號碼格式")
@@ -223,7 +223,7 @@ describe("Taiwan mobile(true) validator", () => {
 
     it("should support whitelist error messages", () => {
       setLocale("en")
-      const schema = mobile(true, {
+      const schema = twMobile(true, {
         whitelist: ["0901234567"],
       })
 
@@ -234,7 +234,7 @@ describe("Taiwan mobile(true) validator", () => {
     })
 
     it("should support custom i18n messages", () => {
-      const schema = mobile(true, {
+      const schema = twMobile(true, {
         i18n: {
           en: {
             required: "Mobile phone is required",
@@ -259,7 +259,7 @@ describe("Taiwan mobile(true) validator", () => {
     })
 
     it("should support custom whitelist messages", () => {
-      const schema = mobile(true, {
+      const schema = twMobile(true, {
         whitelist: ["0901234567"],
         i18n: {
           en: {
@@ -281,7 +281,7 @@ describe("Taiwan mobile(true) validator", () => {
 
   describe("real world Taiwan mobile phone numbers", () => {
     it("should validate all carrier prefixes", () => {
-      const schema = mobile(true)
+      const schema = twMobile(true)
 
       // Test all valid Taiwan mobile prefixes (090-099)
       const validPrefixes = ["090", "091", "092", "093", "094", "095", "096", "097", "098", "099"]
@@ -293,7 +293,7 @@ describe("Taiwan mobile(true) validator", () => {
     })
 
     it("should reject non-mobile phone prefixes", () => {
-      const schema = mobile(true)
+      const schema = twMobile(true)
 
       // Test invalid prefixes
       const invalidPrefixes = ["080", "081", "082", "083", "084", "085", "086", "087", "088", "089"]
@@ -305,7 +305,7 @@ describe("Taiwan mobile(true) validator", () => {
     })
 
     it("should validate realistic phone number patterns", () => {
-      const schema = mobile(true)
+      const schema = twMobile(true)
 
       const realPhoneNumbers = ["0901234567", "0912345678", "0923456789", "0934567890", "0945678901", "0956789012", "0967890123", "0978901234", "0989012345", "0990123456"]
 
@@ -317,15 +317,15 @@ describe("Taiwan mobile(true) validator", () => {
 
   describe("edge cases", () => {
     it("should handle various input types", () => {
-      const schema = mobile(true)
+      const schema = twMobile(true)
 
       // Test different input types that should be converted to string
       expect(schema.parse("0901234567")).toBe("0901234567")
     })
 
     it("should handle empty and whitespace inputs", () => {
-      const schema = mobile(true)
-      const optionalSchema = mobile(false)
+      const schema = twMobile(true)
+      const optionalSchema = twMobile(false)
 
       expect(() => schema.parse("")).toThrow("Required")
       expect(() => schema.parse("   ")).toThrow("Required")
@@ -337,7 +337,7 @@ describe("Taiwan mobile(true) validator", () => {
     })
 
     it("should preserve valid format after transformation", () => {
-      const schema = mobile(true, {
+      const schema = twMobile(true, {
         transform: (val) => val.replace(/[^0-9]/g, ""),
       })
 
@@ -348,7 +348,7 @@ describe("Taiwan mobile(true) validator", () => {
     })
 
     it("should work with complex whitelist scenarios", () => {
-      const schema = mobile(false, { whitelist: ["0901234567", "emergency", "custom-contact-123", ""] })
+      const schema = twMobile(false, { whitelist: ["0901234567", "emergency", "custom-contact-123", ""] })
 
       // Allowlist scenarios
       expect(schema.parse("0901234567")).toBe("0901234567")

package/tests/taiwan/national-id.test.ts

@@ -1,12 +1,12 @@
 import { describe, it, expect, beforeEach } from "vitest"
-import { nationalId, setLocale, validateTaiwanNationalId, validateCitizenId, validateOldResidentId, validateNewResidentId } from "../../src"
+import { twNationalId, setLocale, validateTaiwanNationalId, validateCitizenId, validateOldResidentId, validateNewResidentId } from "../../src"
 
-describe("Taiwan nationalId(true) validator", () => {
+describe("Taiwan twNationalId(true) validator", () => {
   beforeEach(() => setLocale("en"))
 
   describe("basic functionality", () => {
     it("should validate correct Taiwan national IDs (both types)", () => {
-      const schema = nationalId(true)
+      const schema = twNationalId(true)
 
       // Valid citizen IDs (身分證字號)
       expect(schema.parse("A123456789")).toBe("A123456789")
@@ -25,7 +25,7 @@ describe("Taiwan nationalId(true) validator", () => {
     })
 
     it("should reject invalid Taiwan national IDs", () => {
-      const schema = nationalId(true)
+      const schema = twNationalId(true)
 
       // Invalid formats
       expect(() => schema.parse("A12345678")).toThrow("Invalid Taiwan National ID") // Too short
@@ -39,7 +39,7 @@ describe("Taiwan nationalId(true) validator", () => {
     })
 
     it("should handle case conversion", () => {
-      const schema = nationalId(true)
+      const schema = twNationalId(true)
 
       expect(schema.parse("a123456789")).toBe("A123456789")
       expect(schema.parse("b123456780")).toBe("B123456780")
@@ -48,7 +48,7 @@ describe("Taiwan nationalId(true) validator", () => {
 
   describe("type-specific validation", () => {
     it("should validate only citizen IDs when type is 'citizen'", () => {
-      const schema = nationalId(true, { type: "citizen" })
+      const schema = twNationalId(true, { type: "citizen" })
 
       // Should accept citizen IDs
       expect(schema.parse("A123456789")).toBe("A123456789")
@@ -60,7 +60,7 @@ describe("Taiwan nationalId(true) validator", () => {
     })
 
     it("should validate only resident IDs when type is 'resident'", () => {
-      const schema = nationalId(true, { type: "resident" })
+      const schema = twNationalId(true, { type: "resident" })
 
       // Should accept old resident IDs
       expect(schema.parse("AA00000001")).toBe("AA00000001")
@@ -76,7 +76,7 @@ describe("Taiwan nationalId(true) validator", () => {
     })
 
     it("should validate both types when type is 'both' (default)", () => {
-      const schema = nationalId(true, { type: "both" })
+      const schema = twNationalId(true, { type: "both" })
 
       // Should accept all valid formats
       expect(schema.parse("A123456789")).toBe("A123456789") // Citizen
@@ -87,7 +87,7 @@ describe("Taiwan nationalId(true) validator", () => {
 
   describe("allowOldResident option", () => {
     it("should allow old resident IDs by default", () => {
-      const schema = nationalId(true, { type: "resident" })
+      const schema = twNationalId(true, { type: "resident" })
 
       // Should accept old resident IDs (default allowOldResident=true)
       expect(schema.parse("AA00000001")).toBe("AA00000001")
@@ -100,7 +100,7 @@ describe("Taiwan nationalId(true) validator", () => {
     })
 
     it("should reject old resident IDs when allowOldResident=false", () => {
-      const schema = nationalId(true, { type: "resident", allowOldResident: false })
+      const schema = twNationalId(true, { type: "resident", allowOldResident: false })
 
       // Should reject old resident IDs
       expect(() => schema.parse("AA00000001")).toThrow("Invalid Taiwan National ID")
@@ -113,7 +113,7 @@ describe("Taiwan nationalId(true) validator", () => {
     })
 
     it("should work with type='both' and allowOldResident=false", () => {
-      const schema = nationalId(true, { type: "both", allowOldResident: false })
+      const schema = twNationalId(true, { type: "both", allowOldResident: false })
 
       // Should accept citizen IDs
       expect(schema.parse("A123456789")).toBe("A123456789")
@@ -129,8 +129,8 @@ describe("Taiwan nationalId(true) validator", () => {
     })
 
     it("should not affect citizen IDs validation", () => {
-      const schemaWithOld = nationalId(true, { type: "citizen", allowOldResident: true })
-      const schemaWithoutOld = nationalId(true, { type: "citizen", allowOldResident: false })
+      const schemaWithOld = twNationalId(true, { type: "citizen", allowOldResident: true })
+      const schemaWithoutOld = twNationalId(true, { type: "citizen", allowOldResident: false })
 
       // Both should accept citizen IDs
       expect(schemaWithOld.parse("A123456789")).toBe("A123456789")
@@ -211,7 +211,7 @@ describe("Taiwan nationalId(true) validator", () => {
 
   describe("required/optional behavior", () => {
     it("should handle required=true (default)", () => {
-      const schema = nationalId(true)
+      const schema = twNationalId(true)
 
       expect(() => schema.parse("")).toThrow("Required")
       expect(() => schema.parse(null)).toThrow()
@@ -219,7 +219,7 @@ describe("Taiwan nationalId(true) validator", () => {
     })
 
     it("should handle required=false", () => {
-      const schema = nationalId(false)
+      const schema = twNationalId(false)
 
       expect(schema.parse("")).toBe(null)
       expect(schema.parse(null)).toBe(null)
@@ -228,8 +228,8 @@ describe("Taiwan nationalId(true) validator", () => {
     })
 
     it("should use default values", () => {
-      const requiredSchema = nationalId(true, { defaultValue: "A123456789" })
-      const optionalSchema = nationalId(false, { defaultValue: "A123456789" })
+      const requiredSchema = twNationalId(true, { defaultValue: "A123456789" })
+      const optionalSchema = twNationalId(false, { defaultValue: "A123456789" })
 
       expect(requiredSchema.parse("")).toBe("A123456789")
       expect(optionalSchema.parse("")).toBe("A123456789")
@@ -238,7 +238,7 @@ describe("Taiwan nationalId(true) validator", () => {
 
   describe("transform function", () => {
     it("should apply custom transform", () => {
-      const schema = nationalId(true, {
+      const schema = twNationalId(true, {
         transform: (val) => val.replace(/[-\s]/g, "").toUpperCase(),
       })
 
@@ -247,7 +247,7 @@ describe("Taiwan nationalId(true) validator", () => {
     })
 
     it("should apply transform before validation", () => {
-      const schema = nationalId(true, {
+      const schema = twNationalId(true, {
         transform: (val) => val.replace(/\s+/g, "").toUpperCase(),
       })
 
@@ -258,7 +258,7 @@ describe("Taiwan nationalId(true) validator", () => {
 
   describe("input preprocessing", () => {
     it("should handle string conversion and case normalization", () => {
-      const schema = nationalId(true)
+      const schema = twNationalId(true)
 
       // Test automatic uppercase conversion
       expect(schema.parse("a123456789")).toBe("A123456789")
@@ -266,7 +266,7 @@ describe("Taiwan nationalId(true) validator", () => {
     })
 
     it("should trim whitespace", () => {
-      const schema = nationalId(true)
+      const schema = twNationalId(true)
 
       expect(schema.parse("  A123456789  ")).toBe("A123456789")
       expect(schema.parse("\tZ187654324\n")).toBe("Z187654324")
@@ -276,7 +276,7 @@ describe("Taiwan nationalId(true) validator", () => {
   describe("i18n support", () => {
     it("should use English messages by default", () => {
       setLocale("en")
-      const schema = nationalId(true)
+      const schema = twNationalId(true)
 
       expect(() => schema.parse("")).toThrow("Required")
       expect(() => schema.parse("A123456788")).toThrow("Invalid Taiwan National ID")
@@ -284,14 +284,14 @@ describe("Taiwan nationalId(true) validator", () => {
 
     it("should use Chinese messages when locale is zh-TW", () => {
       setLocale("zh-TW")
-      const schema = nationalId(true)
+      const schema = twNationalId(true)
 
       expect(() => schema.parse("")).toThrow("必填")
       expect(() => schema.parse("A123456788")).toThrow("無效的身分證字號")
     })
 
     it("should support custom i18n messages", () => {
-      const schema = nationalId(true, {
+      const schema = twNationalId(true, {
         i18n: {
           en: {
             required: "National ID is required",
@@ -316,7 +316,7 @@ describe("Taiwan nationalId(true) validator", () => {
 
   describe("real world Taiwan national IDs", () => {
     it("should validate known citizen ID patterns", () => {
-      const schema = nationalId(true, { type: "citizen" })
+      const schema = twNationalId(true, { type: "citizen" })
 
       // Test various city codes and gender combinations
       const validCitizenIds = [
@@ -334,7 +334,7 @@ describe("Taiwan nationalId(true) validator", () => {
     })
 
     it("should validate known old resident ID patterns", () => {
-      const schema = nationalId(true, { type: "resident" })
+      const schema = twNationalId(true, { type: "resident" })
 
       // Test old format resident IDs
       const validOldResidentIds = [
@@ -352,7 +352,7 @@ describe("Taiwan nationalId(true) validator", () => {
     })
 
     it("should validate known new resident ID patterns", () => {
-      const schema = nationalId(true, { type: "resident" })
+      const schema = twNationalId(true, { type: "resident" })
 
       // Test new format resident IDs
       const validNewResidentIds = [
@@ -370,7 +370,7 @@ describe("Taiwan nationalId(true) validator", () => {
     })
 
     it("should reject common invalid patterns", () => {
-      const schema = nationalId(true)
+      const schema = twNationalId(true)
 
       const invalidIds = [
         "A000000000", // All zeros
@@ -393,7 +393,7 @@ describe("Taiwan nationalId(true) validator", () => {
 
   describe("edge cases", () => {
     it("should handle all valid city codes", () => {
-      const schema = nationalId(true, { type: "citizen" })
+      const schema = twNationalId(true, { type: "citizen" })
 
       // Test all valid city codes
       const cityCodes = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]
@@ -412,8 +412,8 @@ describe("Taiwan nationalId(true) validator", () => {
     })
 
     it("should handle empty and whitespace inputs", () => {
-      const schema = nationalId(true)
-      const optionalSchema = nationalId(false)
+      const schema = twNationalId(true)
+      const optionalSchema = twNationalId(false)
 
       expect(() => schema.parse("")).toThrow("Required")
       expect(() => schema.parse("   ")).toThrow("Required")
@@ -425,7 +425,7 @@ describe("Taiwan nationalId(true) validator", () => {
     })
 
     it("should preserve valid format after transformation", () => {
-      const schema = nationalId(true, {
+      const schema = twNationalId(true, {
         transform: (val) => val.replace(/[^A-Z0-9]/g, "").toUpperCase(),
       })