@hy_ong/zod-kit 0.2.0 → 0.2.2

package/tests/taiwan/license-plate.test.ts

@@ -0,0 +1,280 @@
+import { describe, it, expect, beforeEach } from "vitest"
+import { twLicensePlate, setLocale, validateTaiwanLicensePlate } from "../../src"
+
+describe("Taiwan twLicensePlate(true) validator", () => {
+  beforeEach(() => setLocale("en-US"))
+
+  describe("basic functionality", () => {
+    it("should validate new-style car plates (3 letters + 4 digits)", () => {
+      const schema = twLicensePlate(true)
+
+      expect(schema.parse("ABC1234")).toBe("ABC1234")
+      expect(schema.parse("XYZ9876")).toBe("XYZ9876")
+    })
+
+    it("should validate new-style car plates with hyphen stripped (ABC-1234)", () => {
+      const schema = twLicensePlate(true)
+
+      expect(schema.parse("ABC-1234")).toBe("ABC1234")
+    })
+
+    it("should validate car plates with 4 digits + 2 letters", () => {
+      const schema = twLicensePlate(true)
+
+      expect(schema.parse("1234AB")).toBe("1234AB")
+      expect(schema.parse("1234-AB")).toBe("1234AB")
+    })
+
+    it("should validate legacy car plates (2 letters + 4 digits)", () => {
+      const schema = twLicensePlate(true)
+
+      expect(schema.parse("AB1234")).toBe("AB1234")
+      expect(schema.parse("AB-1234")).toBe("AB1234")
+    })
+
+    it("should validate legacy mixed car plates (1 letter + 5 digits)", () => {
+      const schema = twLicensePlate(true)
+
+      expect(schema.parse("A12345")).toBe("A12345")
+    })
+
+    it("should validate motorcycle plates (3 digits + 3 letters)", () => {
+      const schema = twLicensePlate(true)
+
+      expect(schema.parse("123ABC")).toBe("123ABC")
+      expect(schema.parse("123-ABC")).toBe("123ABC")
+    })
+
+    it("should auto-uppercase lowercase input", () => {
+      const schema = twLicensePlate(true)
+
+      expect(schema.parse("abc1234")).toBe("ABC1234")
+      expect(schema.parse("abc-1234")).toBe("ABC1234")
+    })
+
+    it("should reject plates that are too short", () => {
+      const schema = twLicensePlate(true)
+
+      expect(() => schema.parse("AB123")).toThrow("Invalid Taiwan license plate number")
+    })
+
+    it("should reject just digits", () => {
+      const schema = twLicensePlate(true)
+
+      expect(() => schema.parse("1234")).toThrow("Invalid Taiwan license plate number")
+      expect(() => schema.parse("1234567")).toThrow("Invalid Taiwan license plate number")
+    })
+
+    it("should reject 4 letters + 4 digits", () => {
+      const schema = twLicensePlate(true)
+
+      expect(() => schema.parse("ABCD1234")).toThrow("Invalid Taiwan license plate number")
+    })
+  })
+
+  describe("plateType option", () => {
+    it("should validate car plates only when plateType is 'car'", () => {
+      const schema = twLicensePlate(true, { plateType: "car" })
+
+      expect(schema.parse("ABC1234")).toBe("ABC1234")
+      expect(schema.parse("1234AB")).toBe("1234AB")
+      expect(schema.parse("AB1234")).toBe("AB1234")
+      expect(schema.parse("A12345")).toBe("A12345")
+    })
+
+    it("should reject motorcycle-only plates when plateType is 'car'", () => {
+      const schema = twLicensePlate(true, { plateType: "car" })
+
+      // 123ABC (3 digits + 3 letters) is motorcycle-only
+      expect(() => schema.parse("123ABC")).toThrow("Invalid Taiwan license plate number")
+    })
+
+    it("should validate motorcycle plates when plateType is 'motorcycle'", () => {
+      const schema = twLicensePlate(true, { plateType: "motorcycle" })
+
+      expect(schema.parse("ABC1234")).toBe("ABC1234")
+      expect(schema.parse("123ABC")).toBe("123ABC")
+      expect(schema.parse("AB1234")).toBe("AB1234")
+      expect(schema.parse("1234AB")).toBe("1234AB")
+    })
+
+    it("should reject car-only plates when plateType is 'motorcycle'", () => {
+      const schema = twLicensePlate(true, { plateType: "motorcycle" })
+
+      // A12345 (1 letter + 5 digits) is car-only
+      expect(() => schema.parse("A12345")).toThrow("Invalid Taiwan license plate number")
+    })
+
+    it("should validate all plate types when plateType is 'any'", () => {
+      const schema = twLicensePlate(true, { plateType: "any" })
+
+      expect(schema.parse("ABC1234")).toBe("ABC1234")
+      expect(schema.parse("1234AB")).toBe("1234AB")
+      expect(schema.parse("AB1234")).toBe("AB1234")
+      expect(schema.parse("A12345")).toBe("A12345")
+      expect(schema.parse("123ABC")).toBe("123ABC")
+    })
+  })
+
+  describe("utility function validateTaiwanLicensePlate", () => {
+    it("should return true for valid plate numbers", () => {
+      expect(validateTaiwanLicensePlate("ABC1234")).toBe(true)
+      expect(validateTaiwanLicensePlate("1234AB")).toBe(true)
+      expect(validateTaiwanLicensePlate("AB1234")).toBe(true)
+      expect(validateTaiwanLicensePlate("A12345")).toBe(true)
+      expect(validateTaiwanLicensePlate("123ABC")).toBe(true)
+    })
+
+    it("should return false for invalid plate numbers", () => {
+      expect(validateTaiwanLicensePlate("AB123")).toBe(false)
+      expect(validateTaiwanLicensePlate("ABCD1234")).toBe(false)
+      expect(validateTaiwanLicensePlate("1234")).toBe(false)
+      expect(validateTaiwanLicensePlate("")).toBe(false)
+      expect(validateTaiwanLicensePlate("abc1234")).toBe(false) // lowercase
+    })
+
+    it("should respect plateType parameter", () => {
+      // A12345 is car-only
+      expect(validateTaiwanLicensePlate("A12345", "car")).toBe(true)
+      expect(validateTaiwanLicensePlate("A12345", "motorcycle")).toBe(false)
+      expect(validateTaiwanLicensePlate("A12345", "any")).toBe(true)
+
+      // 123ABC is motorcycle-only
+      expect(validateTaiwanLicensePlate("123ABC", "motorcycle")).toBe(true)
+      expect(validateTaiwanLicensePlate("123ABC", "car")).toBe(false)
+      expect(validateTaiwanLicensePlate("123ABC", "any")).toBe(true)
+    })
+  })
+
+  describe("required/optional behavior", () => {
+    it("should handle required=true", () => {
+      const schema = twLicensePlate(true)
+
+      expect(() => schema.parse("")).toThrow("Required")
+      expect(() => schema.parse(null)).toThrow()
+      expect(() => schema.parse(undefined)).toThrow()
+    })
+
+    it("should handle required=false", () => {
+      const schema = twLicensePlate(false)
+
+      expect(schema.parse("")).toBe(null)
+      expect(schema.parse(null)).toBe(null)
+      expect(schema.parse(undefined)).toBe(null)
+      expect(schema.parse("ABC1234")).toBe("ABC1234")
+    })
+
+    it("should use default values", () => {
+      const requiredSchema = twLicensePlate(true, { defaultValue: "ABC1234" })
+      const optionalSchema = twLicensePlate(false, { defaultValue: "ABC1234" })
+
+      expect(requiredSchema.parse("")).toBe("ABC1234")
+      expect(optionalSchema.parse("")).toBe("ABC1234")
+    })
+  })
+
+  describe("transform function", () => {
+    it("should apply custom transform", () => {
+      const schema = twLicensePlate(true, {
+        transform: (val) => val.replace(/\s+/g, ""),
+      })
+
+      expect(schema.parse("ABC 1234")).toBe("ABC1234")
+    })
+
+    it("should apply transform before validation", () => {
+      const schema = twLicensePlate(true, {
+        transform: (val) => val.replace(/\s+/g, ""),
+      })
+
+      expect(schema.parse("  ABC1234  ")).toBe("ABC1234")
+    })
+  })
+
+  describe("input preprocessing", () => {
+    it("should trim whitespace", () => {
+      const schema = twLicensePlate(true)
+
+      expect(schema.parse("  ABC1234  ")).toBe("ABC1234")
+      expect(schema.parse("\tABC1234\n")).toBe("ABC1234")
+    })
+
+    it("should strip hyphens and spaces from input", () => {
+      const schema = twLicensePlate(true)
+
+      expect(schema.parse("ABC-1234")).toBe("ABC1234")
+      expect(schema.parse("123-ABC")).toBe("123ABC")
+      expect(schema.parse("AB-1234")).toBe("AB1234")
+    })
+  })
+
+  describe("i18n support", () => {
+    it("should use English messages by default", () => {
+      setLocale("en-US")
+      const schema = twLicensePlate(true)
+
+      expect(() => schema.parse("")).toThrow("Required")
+      expect(() => schema.parse("INVALID")).toThrow("Invalid Taiwan license plate number")
+    })
+
+    it("should use Chinese messages when locale is zh-TW", () => {
+      setLocale("zh-TW")
+      const schema = twLicensePlate(true)
+
+      expect(() => schema.parse("")).toThrow("必填")
+      expect(() => schema.parse("INVALID")).toThrow("無效的車牌號碼")
+    })
+
+    it("should support custom i18n messages", () => {
+      const schema = twLicensePlate(true, {
+        i18n: {
+          "en-US": {
+            required: "Plate number is required",
+            invalid: "Plate number is invalid",
+          },
+          "zh-TW": {
+            required: "請輸入車牌號碼",
+            invalid: "車牌號碼格式錯誤",
+          },
+        },
+      })
+
+      setLocale("en-US")
+      expect(() => schema.parse("")).toThrow("Plate number is required")
+      expect(() => schema.parse("INVALID")).toThrow("Plate number is invalid")
+
+      setLocale("zh-TW")
+      expect(() => schema.parse("")).toThrow("請輸入車牌號碼")
+      expect(() => schema.parse("INVALID")).toThrow("車牌號碼格式錯誤")
+    })
+  })
+
+  describe("edge cases", () => {
+    it("should handle empty and whitespace inputs", () => {
+      const schema = twLicensePlate(true)
+      const optionalSchema = twLicensePlate(false)
+
+      expect(() => schema.parse("")).toThrow("Required")
+      expect(() => schema.parse("   ")).toThrow("Required")
+      expect(() => schema.parse("\t\n")).toThrow("Required")
+
+      expect(optionalSchema.parse("")).toBe(null)
+      expect(optionalSchema.parse("   ")).toBe(null)
+      expect(optionalSchema.parse("\t\n")).toBe(null)
+    })
+
+    it("should reject just letters", () => {
+      const schema = twLicensePlate(true)
+
+      expect(() => schema.parse("ABCDEF")).toThrow("Invalid Taiwan license plate number")
+      expect(() => schema.parse("ABC")).toThrow("Invalid Taiwan license plate number")
+    })
+
+    it("should reject mixed patterns that do not match any format", () => {
+      const schema = twLicensePlate(true)
+
+      expect(() => schema.parse("A1B2C3")).toThrow("Invalid Taiwan license plate number")
+      expect(() => schema.parse("1A2B3C")).toThrow("Invalid Taiwan license plate number")
+    })
+  })
+})

package/tests/taiwan/passport.test.ts

@@ -0,0 +1,277 @@
+import { describe, it, expect, beforeEach } from "vitest"
+import { twPassport, setLocale, validateTaiwanPassport } from "../../src"
+
+describe("Taiwan twPassport(true) validator", () => {
+  beforeEach(() => setLocale("en-US"))
+
+  describe("basic functionality", () => {
+    it("should validate ordinary passport numbers (starts with 2)", () => {
+      const schema = twPassport(true)
+
+      expect(schema.parse("200000001")).toBe("200000001")
+      expect(schema.parse("299999999")).toBe("299999999")
+    })
+
+    it("should validate official passport numbers (starts with 1)", () => {
+      const schema = twPassport(true)
+
+      expect(schema.parse("100000001")).toBe("100000001")
+      expect(schema.parse("199999999")).toBe("199999999")
+    })
+
+    it("should validate diplomatic passport numbers (starts with 0)", () => {
+      const schema = twPassport(true)
+
+      expect(schema.parse("000000001")).toBe("000000001")
+      expect(schema.parse("099999999")).toBe("099999999")
+    })
+
+    it("should validate travel document numbers (starts with 3)", () => {
+      const schema = twPassport(true)
+
+      expect(schema.parse("300000001")).toBe("300000001")
+      expect(schema.parse("399999999")).toBe("399999999")
+    })
+
+    it("should reject passport numbers starting with 4 or higher", () => {
+      const schema = twPassport(true)
+
+      expect(() => schema.parse("400000001")).toThrow("Invalid Taiwan passport number")
+      expect(() => schema.parse("500000001")).toThrow("Invalid Taiwan passport number")
+      expect(() => schema.parse("900000001")).toThrow("Invalid Taiwan passport number")
+    })
+
+    it("should reject passport numbers with wrong length (8 digits)", () => {
+      const schema = twPassport(true)
+
+      expect(() => schema.parse("12345678")).toThrow("Invalid Taiwan passport number")
+    })
+
+    it("should reject passport numbers with wrong length (10 digits)", () => {
+      const schema = twPassport(true)
+
+      expect(() => schema.parse("1234567890")).toThrow("Invalid Taiwan passport number")
+    })
+
+    it("should reject non-numeric input", () => {
+      const schema = twPassport(true)
+
+      expect(() => schema.parse("abcdefghi")).toThrow("Invalid Taiwan passport number")
+      expect(() => schema.parse("12345678A")).toThrow("Invalid Taiwan passport number")
+    })
+  })
+
+  describe("passportType option", () => {
+    it("should accept only ordinary passports (type 2) when passportType is 'ordinary'", () => {
+      const schema = twPassport(true, { passportType: "ordinary" })
+
+      expect(schema.parse("200000001")).toBe("200000001")
+      expect(() => schema.parse("000000001")).toThrow("Invalid Taiwan passport number")
+      expect(() => schema.parse("100000001")).toThrow("Invalid Taiwan passport number")
+      expect(() => schema.parse("300000001")).toThrow("Invalid Taiwan passport number")
+    })
+
+    it("should accept only diplomatic passports (type 0) when passportType is 'diplomatic'", () => {
+      const schema = twPassport(true, { passportType: "diplomatic" })
+
+      expect(schema.parse("000000001")).toBe("000000001")
+      expect(() => schema.parse("100000001")).toThrow("Invalid Taiwan passport number")
+      expect(() => schema.parse("200000001")).toThrow("Invalid Taiwan passport number")
+      expect(() => schema.parse("300000001")).toThrow("Invalid Taiwan passport number")
+    })
+
+    it("should accept only official passports (type 1) when passportType is 'official'", () => {
+      const schema = twPassport(true, { passportType: "official" })
+
+      expect(schema.parse("100000001")).toBe("100000001")
+      expect(() => schema.parse("000000001")).toThrow("Invalid Taiwan passport number")
+      expect(() => schema.parse("200000001")).toThrow("Invalid Taiwan passport number")
+      expect(() => schema.parse("300000001")).toThrow("Invalid Taiwan passport number")
+    })
+
+    it("should accept only travel documents (type 3) when passportType is 'travel'", () => {
+      const schema = twPassport(true, { passportType: "travel" })
+
+      expect(schema.parse("300000001")).toBe("300000001")
+      expect(() => schema.parse("000000001")).toThrow("Invalid Taiwan passport number")
+      expect(() => schema.parse("100000001")).toThrow("Invalid Taiwan passport number")
+      expect(() => schema.parse("200000001")).toThrow("Invalid Taiwan passport number")
+    })
+
+    it("should accept all valid passport types when passportType is 'any'", () => {
+      const schema = twPassport(true, { passportType: "any" })
+
+      expect(schema.parse("000000001")).toBe("000000001")
+      expect(schema.parse("100000001")).toBe("100000001")
+      expect(schema.parse("200000001")).toBe("200000001")
+      expect(schema.parse("300000001")).toBe("300000001")
+    })
+
+    it("should default to 'any' when passportType is not specified", () => {
+      const schema = twPassport(true)
+
+      expect(schema.parse("000000001")).toBe("000000001")
+      expect(schema.parse("100000001")).toBe("100000001")
+      expect(schema.parse("200000001")).toBe("200000001")
+      expect(schema.parse("300000001")).toBe("300000001")
+    })
+  })
+
+  describe("utility function validateTaiwanPassport", () => {
+    it("should return true for valid passport numbers", () => {
+      expect(validateTaiwanPassport("000000001")).toBe(true)
+      expect(validateTaiwanPassport("100000001")).toBe(true)
+      expect(validateTaiwanPassport("200000001")).toBe(true)
+      expect(validateTaiwanPassport("300000001")).toBe(true)
+    })
+
+    it("should return false for invalid passport numbers", () => {
+      expect(validateTaiwanPassport("400000001")).toBe(false)
+      expect(validateTaiwanPassport("12345678")).toBe(false)
+      expect(validateTaiwanPassport("1234567890")).toBe(false)
+      expect(validateTaiwanPassport("abcdefghi")).toBe(false)
+      expect(validateTaiwanPassport("")).toBe(false)
+      expect(validateTaiwanPassport("A00000001")).toBe(false)
+    })
+  })
+
+  describe("required/optional behavior", () => {
+    it("should handle required=true", () => {
+      const schema = twPassport(true)
+
+      expect(() => schema.parse("")).toThrow("Required")
+      expect(() => schema.parse(null)).toThrow()
+      expect(() => schema.parse(undefined)).toThrow()
+    })
+
+    it("should handle required=false", () => {
+      const schema = twPassport(false)
+
+      expect(schema.parse("")).toBe(null)
+      expect(schema.parse(null)).toBe(null)
+      expect(schema.parse(undefined)).toBe(null)
+      expect(schema.parse("200000001")).toBe("200000001")
+    })
+
+    it("should use default values", () => {
+      const requiredSchema = twPassport(true, { defaultValue: "200000001" })
+      const optionalSchema = twPassport(false, { defaultValue: "200000001" })
+
+      expect(requiredSchema.parse("")).toBe("200000001")
+      expect(optionalSchema.parse("")).toBe("200000001")
+    })
+  })
+
+  describe("transform function", () => {
+    it("should apply custom transform", () => {
+      const schema = twPassport(true, {
+        transform: (val) => val.replace(/-/g, ""),
+      })
+
+      expect(schema.parse("200-000-001")).toBe("200000001")
+    })
+
+    it("should apply transform before validation", () => {
+      const schema = twPassport(true, {
+        transform: (val) => val.replace(/\s+/g, ""),
+      })
+
+      expect(schema.parse("  200000001  ")).toBe("200000001")
+      expect(schema.parse("2000 0000 1")).toBe("200000001")
+      // Transform cannot fix non-digit characters
+      expect(() => schema.parse("20000000X")).toThrow("Invalid Taiwan passport number")
+    })
+  })
+
+  describe("input preprocessing", () => {
+    it("should handle string conversion", () => {
+      const schema = twPassport(true)
+
+      expect(schema.parse(200000001)).toBe("200000001")
+    })
+
+    it("should trim whitespace", () => {
+      const schema = twPassport(true)
+
+      expect(schema.parse("  200000001  ")).toBe("200000001")
+      expect(schema.parse("\t200000001\n")).toBe("200000001")
+    })
+  })
+
+  describe("i18n support", () => {
+    it("should use English messages by default", () => {
+      setLocale("en-US")
+      const schema = twPassport(true)
+
+      expect(() => schema.parse("")).toThrow("Required")
+      expect(() => schema.parse("INVALID")).toThrow("Invalid Taiwan passport number")
+    })
+
+    it("should use Chinese messages when locale is zh-TW", () => {
+      setLocale("zh-TW")
+      const schema = twPassport(true)
+
+      expect(() => schema.parse("")).toThrow("必填")
+      expect(() => schema.parse("INVALID")).toThrow("無效的護照號碼")
+    })
+
+    it("should support custom i18n messages", () => {
+      const schema = twPassport(true, {
+        i18n: {
+          "en-US": {
+            required: "Passport number is required",
+            invalid: "Passport number is invalid",
+          },
+          "zh-TW": {
+            required: "請輸入護照號碼",
+            invalid: "護照號碼格式錯誤",
+          },
+        },
+      })
+
+      setLocale("en-US")
+      expect(() => schema.parse("")).toThrow("Passport number is required")
+      expect(() => schema.parse("INVALID")).toThrow("Passport number is invalid")
+
+      setLocale("zh-TW")
+      expect(() => schema.parse("")).toThrow("請輸入護照號碼")
+      expect(() => schema.parse("INVALID")).toThrow("護照號碼格式錯誤")
+    })
+  })
+
+  describe("edge cases", () => {
+    it("should handle empty and whitespace inputs", () => {
+      const schema = twPassport(true)
+      const optionalSchema = twPassport(false)
+
+      expect(() => schema.parse("")).toThrow("Required")
+      expect(() => schema.parse("   ")).toThrow("Required")
+      expect(() => schema.parse("\t\n")).toThrow("Required")
+
+      expect(optionalSchema.parse("")).toBe(null)
+      expect(optionalSchema.parse("   ")).toBe(null)
+      expect(optionalSchema.parse("\t\n")).toBe(null)
+    })
+
+    it("should handle boundary values", () => {
+      const schema = twPassport(true)
+
+      expect(schema.parse("000000000")).toBe("000000000")
+      expect(schema.parse("399999999")).toBe("399999999")
+    })
+
+    it("should reject passport numbers with leading spaces that break digit count", () => {
+      const schema = twPassport(true)
+
+      // After trim, "2 00000001" becomes "2 00000001" which has a space
+      expect(() => schema.parse("2 00000001")).toThrow("Invalid Taiwan passport number")
+    })
+
+    it("should reject mixed alphanumeric input", () => {
+      const schema = twPassport(true)
+
+      expect(() => schema.parse("2A0000001")).toThrow("Invalid Taiwan passport number")
+      expect(() => schema.parse("20000000A")).toThrow("Invalid Taiwan passport number")
+    })
+  })
+})

package/tsup.config.ts

@@ -0,0 +1,36 @@
+import { defineConfig } from "tsup"
+
+export default defineConfig({
+  entry: {
+    index: "src/index.ts",
+    "common/boolean": "src/validators/common/boolean.ts",
+    "common/date": "src/validators/common/date.ts",
+    "common/datetime": "src/validators/common/datetime.ts",
+    "common/email": "src/validators/common/email.ts",
+    "common/file": "src/validators/common/file.ts",
+    "common/id": "src/validators/common/id.ts",
+    "common/number": "src/validators/common/number.ts",
+    "common/password": "src/validators/common/password.ts",
+    "common/text": "src/validators/common/text.ts",
+    "common/time": "src/validators/common/time.ts",
+    "common/url": "src/validators/common/url.ts",
+    "common/credit-card": "src/validators/common/credit-card.ts",
+    "common/ip": "src/validators/common/ip.ts",
+    "common/color": "src/validators/common/color.ts",
+    "common/coordinate": "src/validators/common/coordinate.ts",
+    "taiwan/business-id": "src/validators/taiwan/business-id.ts",
+    "taiwan/national-id": "src/validators/taiwan/national-id.ts",
+    "taiwan/mobile": "src/validators/taiwan/mobile.ts",
+    "taiwan/postal-code": "src/validators/taiwan/postal-code.ts",
+    "taiwan/tel": "src/validators/taiwan/tel.ts",
+    "taiwan/fax": "src/validators/taiwan/fax.ts",
+    "taiwan/invoice": "src/validators/taiwan/invoice.ts",
+    "taiwan/license-plate": "src/validators/taiwan/license-plate.ts",
+    "taiwan/bank-account": "src/validators/taiwan/bank-account.ts",
+    "taiwan/passport": "src/validators/taiwan/passport.ts",
+  },
+  format: ["esm", "cjs"],
+  dts: true,
+  clean: true,
+  splitting: true,
+})