@hy_ong/zod-kit 0.0.5 → 0.1.0

package/tests/common/url.test.ts

@@ -4,123 +4,123 @@ import { setLocale, url } from "../../src"
 describe("url", () => {
   describe("basic validation", () => {
     it("should validate valid URL", () => {
-      const schema = url()
+      const schema = url(true)
       expect(schema.parse("https://example.com")).toBe("https://example.com")
     })
 
     it("should validate http URL", () => {
-      const schema = url()
+      const schema = url(true)
       expect(schema.parse("http://example.com")).toBe("http://example.com")
     })
 
     it("should validate URL with path", () => {
-      const schema = url()
+      const schema = url(true)
       expect(schema.parse("https://example.com/path")).toBe("https://example.com/path")
     })
 
     it("should validate URL with query parameters", () => {
-      const schema = url()
+      const schema = url(true)
       expect(schema.parse("https://example.com?param=value")).toBe("https://example.com?param=value")
     })
 
     it("should validate URL with fragment", () => {
-      const schema = url()
+      const schema = url(true)
       expect(schema.parse("https://example.com#section")).toBe("https://example.com#section")
     })
 
     it("should reject invalid URL format", () => {
-      const schema = url()
+      const schema = url(true)
       expect(() => schema.parse("invalid-url")).toThrow()
     })
 
     it("should reject empty string", () => {
-      const schema = url()
+      const schema = url(true)
       expect(() => schema.parse("")).toThrow()
     })
 
     it("should reject null", () => {
-      const schema = url()
+      const schema = url(true)
       expect(() => schema.parse(null)).toThrow()
     })
 
     it("should reject undefined", () => {
-      const schema = url()
+      const schema = url(true)
       expect(() => schema.parse(undefined)).toThrow()
     })
   })
 
   describe("optional", () => {
     it("should allow null when not required", () => {
-      const schema = url({ required: false })
+      const schema = url(false)
       expect(schema.parse(null)).toBe(null)
     })
 
     it("should allow empty string when not required", () => {
-      const schema = url({ required: false })
+      const schema = url(false)
       expect(schema.parse("")).toBe(null)
     })
 
     it("should allow undefined when not required", () => {
-      const schema = url({ required: false })
+      const schema = url(false)
       expect(schema.parse(undefined)).toBe(null)
     })
 
     it("should validate valid URL when not required", () => {
-      const schema = url({ required: false })
+      const schema = url(false)
       expect(schema.parse("https://example.com")).toBe("https://example.com")
     })
   })
 
   describe("length validation", () => {
     it("should accept URL with valid min length", () => {
-      const schema = url({ min: 10 })
+      const schema = url(true, { min: 10 })
       expect(schema.parse("https://example.com")).toBe("https://example.com")
     })
 
     it("should reject URL below min length", () => {
-      const schema = url({ min: 30 })
+      const schema = url(true, { min: 30 })
       expect(() => schema.parse("https://short.co")).toThrow()
     })
 
     it("should accept URL with valid max length", () => {
-      const schema = url({ max: 30 })
+      const schema = url(true, { max: 30 })
       expect(schema.parse("https://example.com")).toBe("https://example.com")
     })
 
     it("should reject URL above max length", () => {
-      const schema = url({ max: 10 })
+      const schema = url(true, { max: 10 })
       expect(() => schema.parse("https://verylongurl.com")).toThrow()
     })
 
     it("should accept URL within range", () => {
-      const schema = url({ min: 10, max: 30 })
+      const schema = url(true, { min: 10, max: 30 })
       expect(schema.parse("https://example.com")).toBe("https://example.com")
     })
   })
 
   describe("includes/excludes validation", () => {
     it("should accept URL containing required substring", () => {
-      const schema = url({ includes: "company" })
+      const schema = url(true, { includes: "company" })
       expect(schema.parse("https://company.example.com")).toBe("https://company.example.com")
     })
 
     it("should reject URL not containing required substring", () => {
-      const schema = url({ includes: "company" })
+      const schema = url(true, { includes: "company" })
       expect(() => schema.parse("https://other.com")).toThrow()
     })
 
     it("should accept URL not containing excluded substring", () => {
-      const schema = url({ excludes: "banned" })
+      const schema = url(true, { excludes: "banned" })
       expect(schema.parse("https://example.com")).toBe("https://example.com")
     })
 
     it("should reject URL containing excluded substring", () => {
-      const schema = url({ excludes: "banned" })
+      const schema = url(true, { excludes: "banned" })
       expect(() => schema.parse("https://banned.com")).toThrow()
     })
 
     it("should handle multiple excluded substrings as array", () => {
-      const schema = url({ excludes: ["banned", "blocked"] })
+      const schema = url(true, { excludes: ["banned", "blocked"] })
       expect(schema.parse("https://example.com")).toBe("https://example.com")
       expect(() => schema.parse("https://banned.com")).toThrow()
       expect(() => schema.parse("https://blocked.com")).toThrow()
@@ -129,36 +129,36 @@ describe("url", () => {
 
   describe("protocol validation", () => {
     it("should accept allowed protocols", () => {
-      const schema = url({ protocols: ["https", "http"] })
+      const schema = url(true, { protocols: ["https", "http"] })
       expect(schema.parse("https://example.com")).toBe("https://example.com")
       expect(schema.parse("http://example.com")).toBe("http://example.com")
     })
 
     it("should reject disallowed protocols", () => {
-      const schema = url({ protocols: ["https"] })
+      const schema = url(true, { protocols: ["https"] })
       expect(() => schema.parse("http://example.com")).toThrow()
     })
 
     it("should accept ftp protocol when allowed", () => {
-      const schema = url({ protocols: ["ftp"] })
+      const schema = url(true, { protocols: ["ftp"] })
       expect(schema.parse("ftp://files.example.com")).toBe("ftp://files.example.com")
     })
   })
 
   describe("domain validation", () => {
     it("should accept allowed domains", () => {
-      const schema = url({ allowedDomains: ["example.com", "test.org"] })
+      const schema = url(true, { allowedDomains: ["example.com", "test.org"] })
       expect(schema.parse("https://example.com")).toBe("https://example.com")
       expect(schema.parse("https://sub.example.com")).toBe("https://sub.example.com")
     })
 
     it("should reject disallowed domains", () => {
-      const schema = url({ allowedDomains: ["example.com"] })
+      const schema = url(true, { allowedDomains: ["example.com"] })
       expect(() => schema.parse("https://other.com")).toThrow()
     })
 
     it("should reject blocked domains", () => {
-      const schema = url({ blockedDomains: ["blocked.com", "spam.org"] })
+      const schema = url(true, { blockedDomains: ["blocked.com", "spam.org"] })
       expect(schema.parse("https://example.com")).toBe("https://example.com")
       expect(() => schema.parse("https://blocked.com")).toThrow()
       expect(() => schema.parse("https://sub.blocked.com")).toThrow()
@@ -167,19 +167,19 @@ describe("url", () => {
 
   describe("port validation", () => {
     it("should accept allowed ports", () => {
-      const schema = url({ allowedPorts: [80, 443, 8080] })
+      const schema = url(true, { allowedPorts: [80, 443, 8080] })
       expect(schema.parse("https://example.com")).toBe("https://example.com") // 443
       expect(schema.parse("http://example.com")).toBe("http://example.com") // 80
       expect(schema.parse("https://example.com:8080")).toBe("https://example.com:8080")
     })
 
     it("should reject disallowed ports", () => {
-      const schema = url({ allowedPorts: [443] })
+      const schema = url(true, { allowedPorts: [443] })
       expect(() => schema.parse("http://example.com")).toThrow() // Port 80
     })
 
     it("should reject blocked ports", () => {
-      const schema = url({ blockedPorts: [80] })
+      const schema = url(true, { blockedPorts: [80] })
       expect(schema.parse("https://example.com")).toBe("https://example.com") // 443
       expect(() => schema.parse("http://example.com")).toThrow() // Port 80
     })
@@ -187,80 +187,80 @@ describe("url", () => {
 
   describe("path validation", () => {
     it("should accept path starting with required prefix", () => {
-      const schema = url({ pathStartsWith: "/api" })
+      const schema = url(true, { pathStartsWith: "/api" })
       expect(schema.parse("https://example.com/api/users")).toBe("https://example.com/api/users")
     })
 
     it("should reject path not starting with required prefix", () => {
-      const schema = url({ pathStartsWith: "/api" })
+      const schema = url(true, { pathStartsWith: "/api" })
       expect(() => schema.parse("https://example.com/web/users")).toThrow()
     })
 
     it("should accept path ending with required suffix", () => {
-      const schema = url({ pathEndsWith: ".json" })
+      const schema = url(true, { pathEndsWith: ".json" })
       expect(schema.parse("https://example.com/api/data.json")).toBe("https://example.com/api/data.json")
     })
 
     it("should reject path not ending with required suffix", () => {
-      const schema = url({ pathEndsWith: ".json" })
+      const schema = url(true, { pathEndsWith: ".json" })
       expect(() => schema.parse("https://example.com/api/data.xml")).toThrow()
     })
   })
 
   describe("query validation", () => {
     it("should accept URL with query when required", () => {
-      const schema = url({ mustHaveQuery: true })
+      const schema = url(true, { mustHaveQuery: true })
       expect(schema.parse("https://example.com?param=value")).toBe("https://example.com?param=value")
     })
 
     it("should reject URL without query when required", () => {
-      const schema = url({ mustHaveQuery: true })
+      const schema = url(true, { mustHaveQuery: true })
       expect(() => schema.parse("https://example.com")).toThrow()
     })
 
     it("should accept URL without query when forbidden", () => {
-      const schema = url({ mustNotHaveQuery: true })
+      const schema = url(true, { mustNotHaveQuery: true })
       expect(schema.parse("https://example.com")).toBe("https://example.com")
     })
 
     it("should reject URL with query when forbidden", () => {
-      const schema = url({ mustNotHaveQuery: true })
+      const schema = url(true, { mustNotHaveQuery: true })
       expect(() => schema.parse("https://example.com?param=value")).toThrow()
     })
   })
 
   describe("fragment validation", () => {
     it("should accept URL with fragment when required", () => {
-      const schema = url({ mustHaveFragment: true })
+      const schema = url(true, { mustHaveFragment: true })
       expect(schema.parse("https://example.com#section")).toBe("https://example.com#section")
     })
 
     it("should reject URL without fragment when required", () => {
-      const schema = url({ mustHaveFragment: true })
+      const schema = url(true, { mustHaveFragment: true })
       expect(() => schema.parse("https://example.com")).toThrow()
     })
 
     it("should accept URL without fragment when forbidden", () => {
-      const schema = url({ mustNotHaveFragment: true })
+      const schema = url(true, { mustNotHaveFragment: true })
       expect(schema.parse("https://example.com")).toBe("https://example.com")
     })
 
     it("should reject URL with fragment when forbidden", () => {
-      const schema = url({ mustNotHaveFragment: true })
+      const schema = url(true, { mustNotHaveFragment: true })
       expect(() => schema.parse("https://example.com#section")).toThrow()
     })
   })
 
   describe("localhost validation", () => {
     it("should allow localhost by default", () => {
-      const schema = url()
+      const schema = url(true)
       expect(schema.parse("http://localhost:3000")).toBe("http://localhost:3000")
       expect(schema.parse("http://127.0.0.1")).toBe("http://127.0.0.1")
       expect(schema.parse("http://192.168.1.1")).toBe("http://192.168.1.1")
     })
 
     it("should block localhost when blockLocalhost is true", () => {
-      const schema = url({ blockLocalhost: true })
+      const schema = url(true, { blockLocalhost: true })
       expect(schema.parse("https://example.com")).toBe("https://example.com")
       expect(() => schema.parse("http://localhost:3000")).toThrow()
       expect(() => schema.parse("http://127.0.0.1")).toThrow()
@@ -268,19 +268,19 @@ describe("url", () => {
     })
 
     it("should block localhost when allowLocalhost is false", () => {
-      const schema = url({ allowLocalhost: false })
+      const schema = url(true, { allowLocalhost: false })
       expect(() => schema.parse("http://localhost:3000")).toThrow()
     })
   })
 
   describe("transform function", () => {
     it("should apply custom transform function", () => {
-      const schema = url({ transform: (val) => val.replace("http://", "https://") })
+      const schema = url(true, { transform: (val) => val.replace("http://", "https://") })
       expect(schema.parse("http://example.com")).toBe("https://example.com")
     })
 
     it("should apply transform before validation", () => {
-      const schema = url({
+      const schema = url(true, {
         protocols: ["https"],
         transform: (val) => val.replace("http://", "https://"),
       })
@@ -288,7 +288,7 @@ describe("url", () => {
     })
 
     it("should work with other validations after transform", () => {
-      const schema = url({
+      const schema = url(true, {
         includes: "https",
         transform: (val) => val.replace("http://", "https://"),
       })
@@ -298,14 +298,14 @@ describe("url", () => {
 
   describe("default value", () => {
     it("should use default value when input is empty", () => {
-      const schema = url({ defaultValue: "https://example.com" })
+      const schema = url(true, { defaultValue: "https://example.com" })
       expect(schema.parse("")).toBe("https://example.com")
       expect(schema.parse(null)).toBe("https://example.com")
       expect(schema.parse(undefined)).toBe("https://example.com")
     })
 
     it("should use default value when optional and input is empty", () => {
-      const schema = url({ required: false, defaultValue: "https://example.com" })
+      const schema = url(false, { defaultValue: "https://example.com" })
       expect(schema.parse("")).toBe("https://example.com")
       expect(schema.parse(null)).toBe("https://example.com")
       expect(schema.parse(undefined)).toBe("https://example.com")
@@ -314,7 +314,7 @@ describe("url", () => {
 
   describe("i18n custom messages", () => {
     it("should use custom English messages", () => {
-      const schema = url({
+      const schema = url(true, {
         i18n: {
           en: { invalid: "Custom URL format error" },
           "zh-TW": { invalid: "自定義 URL 格式錯誤" },
@@ -330,7 +330,7 @@ describe("url", () => {
     })
 
     it("should use custom Chinese messages", () => {
-      const schema = url({
+      const schema = url(true, {
         i18n: {
           en: { invalid: "Custom URL format error" },
           "zh-TW": { invalid: "自定義 URL 格式錯誤" },
@@ -346,7 +346,7 @@ describe("url", () => {
     })
 
     it("should fallback to default messages when custom not provided", () => {
-      const schema = url({
+      const schema = url(true, {
         i18n: {
           en: { invalid: "Custom invalid error" },
           "zh-TW": { invalid: "自定義無效錯誤" },
@@ -362,7 +362,7 @@ describe("url", () => {
     })
 
     it("should handle protocol validation with custom message", () => {
-      const schema = url({
+      const schema = url(true, {
         protocols: ["https"],
         i18n: {
           en: { protocol: "Only HTTPS allowed!" },
@@ -379,7 +379,7 @@ describe("url", () => {
     })
 
     it("should handle domain validation with custom message", () => {
-      const schema = url({
+      const schema = url(true, {
         allowedDomains: ["example.com"],
         i18n: {
           en: { domain: "Only example.com allowed!" },
@@ -399,7 +399,7 @@ describe("url", () => {
   describe("localization", () => {
     it("should use English error messages", () => {
       setLocale("en")
-      const schema = url()
+      const schema = url(true)
 
       try {
         schema.parse("invalid")
@@ -410,7 +410,7 @@ describe("url", () => {
 
     it("should use Chinese error messages", () => {
       setLocale("zh-TW")
-      const schema = url()
+      const schema = url(true)
 
       try {
         schema.parse("invalid")
@@ -421,7 +421,7 @@ describe("url", () => {
 
     it("should use Chinese domain validation messages", () => {
       setLocale("zh-TW")
-      const schema = url({ allowedDomains: ["example.com"] })
+      const schema = url(true, { allowedDomains: ["example.com"] })
 
       try {
         schema.parse("https://other.com")
@@ -433,7 +433,7 @@ describe("url", () => {
 
   describe("complex scenarios", () => {
     it("should handle multiple validations combined", () => {
-      const schema = url({
+      const schema = url(true, {
         protocols: ["https"],
         allowedDomains: ["example.com"],
         min: 20,
@@ -451,7 +451,7 @@ describe("url", () => {
     })
 
     it("should handle localhost detection in private networks", () => {
-      const schema = url({ blockLocalhost: true })
+      const schema = url(true, { blockLocalhost: true })
 
       expect(() => schema.parse("http://10.0.0.1")).toThrow()
       expect(() => schema.parse("http://172.16.0.1")).toThrow()
@@ -460,7 +460,7 @@ describe("url", () => {
     })
 
     it("should handle edge cases with ports", () => {
-      const schema = url({ allowedPorts: [443, 8080] })
+      const schema = url(true, { allowedPorts: [443, 8080] })
 
       expect(schema.parse("https://example.com")).toBe("https://example.com") // Default 443
       expect(schema.parse("https://example.com:8080")).toBe("https://example.com:8080")
@@ -470,24 +470,24 @@ describe("url", () => {
 
   describe("edge cases", () => {
     it("should handle URLs with special characters", () => {
-      const schema = url()
+      const schema = url(true)
       expect(schema.parse("https://example.com/path%20with%20spaces")).toBe("https://example.com/path%20with%20spaces")
     })
 
     it("should handle international domain names", () => {
-      const schema = url()
+      const schema = url(true)
       expect(schema.parse("https://xn--fsq.com")).toBe("https://xn--fsq.com") // Internationalized domain
     })
 
     it("should handle URLs with authentication", () => {
-      const schema = url()
+      const schema = url(true)
       expect(schema.parse("https://user:pass@example.com")).toBe("https://user:pass@example.com")
     })
 
     it("should handle very long URLs", () => {
       const longPath = "/very/long/path/" + "segment/".repeat(100)
       const longUrl = `https://example.com${longPath}`
-      const schema = url()
+      const schema = url(true)
       expect(schema.parse(longUrl)).toBe(longUrl)
     })
   })

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

@@ -1,12 +1,12 @@
 import { describe, it, expect, beforeEach } from "vitest"
 import { businessId, setLocale, validateTaiwanBusinessId } from "../../src"
 
-describe("Taiwan businessId() validator", () => {
+describe("Taiwan businessId(true) validator", () => {
   beforeEach(() => setLocale("en"))
 
   describe("basic functionality", () => {
     it("should validate correct Taiwan business IDs", () => {
-      const schema = businessId()
+      const schema = businessId(true)
 
       // Valid Taiwan business IDs (統一編號) - using calculation based on new/old rules
       expect(schema.parse("22550077")).toBe("22550077") // Sum = 50, 50 % 5 = 0 (new rule)
@@ -15,7 +15,7 @@ describe("Taiwan businessId() validator", () => {
     })
 
     it("should reject invalid Taiwan business IDs", () => {
-      const schema = businessId()
+      const schema = businessId(true)
 
       // Invalid checksums
       expect(() => schema.parse("12345672")).toThrow("Invalid Taiwan Business ID")
@@ -24,7 +24,7 @@ describe("Taiwan businessId() validator", () => {
     })
 
     it("should reject non-numeric inputs", () => {
-      const schema = businessId()
+      const schema = businessId(true)
 
       expect(() => schema.parse("1234567A")).toThrow("Invalid Taiwan Business ID")
       expect(() => schema.parse("abcdefgh")).toThrow("Invalid Taiwan Business ID")
@@ -32,7 +32,7 @@ describe("Taiwan businessId() validator", () => {
     })
 
     it("should reject wrong length inputs", () => {
-      const schema = businessId()
+      const schema = businessId(true)
 
       expect(() => schema.parse("1234567")).toThrow("Invalid Taiwan Business ID")
       expect(() => schema.parse("123456789")).toThrow("Invalid Taiwan Business ID")
@@ -43,7 +43,7 @@ describe("Taiwan businessId() validator", () => {
 
   describe("special case validation (7th digit = 7)", () => {
     it("should handle special case where 7th digit is 7", () => {
-      const schema = businessId()
+      const schema = businessId(true)
 
       // Valid number with 7th digit = 7 for testing special case
       expect(schema.parse("12345670")).toBe("12345670") // Should be valid with special case
@@ -75,7 +75,7 @@ describe("Taiwan businessId() validator", () => {
 
   describe("required/optional behavior", () => {
     it("should handle required=true (default)", () => {
-      const schema = businessId()
+      const schema = businessId(true)
 
       expect(() => schema.parse("")).toThrow("Required")
       expect(() => schema.parse(null)).toThrow()
@@ -83,7 +83,7 @@ describe("Taiwan businessId() validator", () => {
     })
 
     it("should handle required=false", () => {
-      const schema = businessId({ required: false })
+      const schema = businessId(false)
 
       expect(schema.parse("")).toBe(null)
       expect(schema.parse(null)).toBe(null)
@@ -92,8 +92,8 @@ describe("Taiwan businessId() validator", () => {
     })
 
     it("should use default values", () => {
-      const requiredSchema = businessId({ defaultValue: "12345675" })
-      const optionalSchema = businessId({ required: false, defaultValue: "12345675" })
+      const requiredSchema = businessId(true, { defaultValue: "12345675" })
+      const optionalSchema = businessId(false, { defaultValue: "12345675" })
 
       expect(requiredSchema.parse("")).toBe("12345675")
       expect(optionalSchema.parse("")).toBe("12345675")
@@ -102,7 +102,7 @@ describe("Taiwan businessId() validator", () => {
 
   describe("transform function", () => {
     it("should apply custom transform", () => {
-      const schema = businessId({
+      const schema = businessId(true, {
         transform: (val) => val.replace(/[-\s]/g, ""),
       })
 
@@ -112,7 +112,7 @@ describe("Taiwan businessId() validator", () => {
     })
 
     it("should apply transform before validation", () => {
-      const schema = businessId({
+      const schema = businessId(true, {
         transform: (val) => val.replace(/\s+/g, ""),
       })
 
@@ -123,14 +123,14 @@ describe("Taiwan businessId() validator", () => {
 
   describe("input preprocessing", () => {
     it("should handle string conversion", () => {
-      const schema = businessId()
+      const schema = businessId(true)
 
       expect(schema.parse(12345675)).toBe("12345675")
       expect(() => schema.parse(12345672)).toThrow("Invalid Taiwan Business ID")
     })
 
     it("should trim whitespace", () => {
-      const schema = businessId()
+      const schema = businessId(true)
 
       expect(schema.parse("  12345675  ")).toBe("12345675")
       expect(schema.parse("\t12345675\n")).toBe("12345675")
@@ -140,7 +140,7 @@ describe("Taiwan businessId() validator", () => {
   describe("i18n support", () => {
     it("should use English messages by default", () => {
       setLocale("en")
-      const schema = businessId()
+      const schema = businessId(true)
 
       expect(() => schema.parse("")).toThrow("Required")
       expect(() => schema.parse("1234567")).toThrow("Invalid Taiwan Business ID")
@@ -149,7 +149,7 @@ describe("Taiwan businessId() validator", () => {
 
     it("should use Chinese messages when locale is zh-TW", () => {
       setLocale("zh-TW")
-      const schema = businessId()
+      const schema = businessId(true)
 
       expect(() => schema.parse("")).toThrow("必填")
       expect(() => schema.parse("1234567")).toThrow("無效的統一編號")
@@ -157,7 +157,7 @@ describe("Taiwan businessId() validator", () => {
     })
 
     it("should support custom i18n messages", () => {
-      const schema = businessId({
+      const schema = businessId(true, {
         i18n: {
           en: {
             required: "Business ID is required",
@@ -182,7 +182,7 @@ describe("Taiwan businessId() validator", () => {
 
   describe("real world Taiwan business IDs", () => {
     it("should validate known real business IDs", () => {
-      const schema = businessId()
+      const schema = businessId(true)
 
       // These are example valid Taiwan business IDs for testing
       const validIds = [
@@ -198,7 +198,7 @@ describe("Taiwan businessId() validator", () => {
     })
 
     it("should reject common invalid patterns", () => {
-      const schema = businessId()
+      const schema = businessId(true)
 
       const invalidIds = [
         "00000001", // All zeros with bad checksum
@@ -218,15 +218,15 @@ describe("Taiwan businessId() validator", () => {
 
   describe("edge cases", () => {
     it("should handle leading zeros", () => {
-      const schema = businessId()
+      const schema = businessId(true)
 
       expect(schema.parse("04595257")).toBe("04595257")
       expect(() => schema.parse("00123456")).toThrow("Invalid Taiwan Business ID")
     })
 
     it("should handle empty and whitespace inputs", () => {
-      const schema = businessId()
-      const optionalSchema = businessId({ required: false })
+      const schema = businessId(true)
+      const optionalSchema = businessId(false)
 
       expect(() => schema.parse("")).toThrow("Required")
       expect(() => schema.parse("   ")).toThrow("Required")