@hy_ong/zod-kit 0.0.6 → 0.1.1

package/tests/taiwan/postal-code.test.ts

@@ -6,7 +6,7 @@ describe("postalCode() features", () => {
 
   describe("3-digit postal code validation", () => {
     it("should accept valid 3-digit postal codes", () => {
-      const schema = postalCode({ format: "3" })
+      const schema = postalCode(true, { format: "3" })
       expect(schema.parse("100")).toBe("100") // Taipei
       expect(schema.parse("200")).toBe("200") // Keelung
       expect(schema.parse("300")).toBe("300") // Taoyuan/Hsinchu
@@ -19,20 +19,20 @@ describe("postalCode() features", () => {
     })
 
     it("should reject invalid 3-digit postal codes", () => {
-      const schema = postalCode({ format: "3" })
+      const schema = postalCode(true, { format: "3" })
       expect(() => schema.parse("000")).toThrow("Invalid Taiwan postal code")
       expect(() => schema.parse("099")).toThrow("Invalid Taiwan postal code")
       expect(() => schema.parse("999")).toThrow("Invalid Taiwan postal code")
     })
 
     it("should reject non-3-digit formats when format is '3'", () => {
-      const schema = postalCode({ format: "3" })
+      const schema = postalCode(true, { format: "3" })
       expect(() => schema.parse("10001")).toThrow("Only 3-digit postal codes are allowed")
       expect(() => schema.parse("100001")).toThrow("Only 3-digit postal codes are allowed")
     })
 
     it("should validate specific Taipei area postal codes", () => {
-      const schema = postalCode({ format: "3" })
+      const schema = postalCode(true, { format: "3" })
       expect(schema.parse("100")).toBe("100") // Zhongzheng
       expect(schema.parse("103")).toBe("103") // Datong
       expect(schema.parse("104")).toBe("104") // Zhongshan
@@ -50,7 +50,7 @@ describe("postalCode() features", () => {
 
   describe("5-digit postal code validation", () => {
     it("should accept valid 5-digit postal codes", () => {
-      const schema = postalCode({ format: "5" })
+      const schema = postalCode(true, { format: "5" })
       expect(schema.parse("10001")).toBe("10001")
       expect(schema.parse("20001")).toBe("20001")
       expect(schema.parse("30001")).toBe("30001")
@@ -59,20 +59,20 @@ describe("postalCode() features", () => {
     })
 
     it("should reject invalid 5-digit postal codes", () => {
-      const schema = postalCode({ format: "5" })
+      const schema = postalCode(true, { format: "5" })
       expect(() => schema.parse("00001")).toThrow("Invalid Taiwan postal code")
       expect(() => schema.parse("09901")).toThrow("Invalid Taiwan postal code")
       expect(() => schema.parse("99901")).toThrow("Invalid Taiwan postal code")
     })
 
     it("should reject non-5-digit formats when format is '5'", () => {
-      const schema = postalCode({ format: "5" })
+      const schema = postalCode(true, { format: "5" })
       expect(() => schema.parse("100")).toThrow("Only 5-digit postal codes are allowed")
       expect(() => schema.parse("100001")).toThrow("Only 5-digit postal codes are allowed")
     })
 
     it("should validate 5-digit postal codes with valid prefixes", () => {
-      const schema = postalCode({ format: "5" })
+      const schema = postalCode(true, { format: "5" })
       expect(schema.parse("10099")).toBe("10099") // Valid Taipei prefix
       expect(schema.parse("20099")).toBe("20099") // Valid Keelung prefix
       expect(schema.parse("88099")).toBe("88099") // Valid Penghu prefix
@@ -81,7 +81,7 @@ describe("postalCode() features", () => {
 
   describe("6-digit postal code validation", () => {
     it("should accept valid 6-digit postal codes", () => {
-      const schema = postalCode({ format: "6" })
+      const schema = postalCode(true, { format: "6" })
       expect(schema.parse("100001")).toBe("100001")
       expect(schema.parse("200001")).toBe("200001")
       expect(schema.parse("300001")).toBe("300001")
@@ -90,20 +90,20 @@ describe("postalCode() features", () => {
     })
 
     it("should reject invalid 6-digit postal codes", () => {
-      const schema = postalCode({ format: "6" })
+      const schema = postalCode(true, { format: "6" })
       expect(() => schema.parse("000001")).toThrow("Invalid Taiwan postal code")
       expect(() => schema.parse("099001")).toThrow("Invalid Taiwan postal code")
       expect(() => schema.parse("999001")).toThrow("Invalid Taiwan postal code")
     })
 
     it("should reject non-6-digit formats when format is '6'", () => {
-      const schema = postalCode({ format: "6" })
+      const schema = postalCode(true, { format: "6" })
       expect(() => schema.parse("100")).toThrow("Only 6-digit postal codes are allowed")
       expect(() => schema.parse("10001")).toThrow("Only 6-digit postal codes are allowed")
     })
 
     it("should validate 6-digit postal codes with all valid prefixes", () => {
-      const schema = postalCode({ format: "6" })
+      const schema = postalCode(true, { format: "6" })
       expect(schema.parse("100999")).toBe("100999") // Taipei
       expect(schema.parse("880999")).toBe("880999") // Penghu
       expect(schema.parse("890999")).toBe("890999") // Kinmen
@@ -113,7 +113,7 @@ describe("postalCode() features", () => {
 
   describe("combined format validation", () => {
     it("should accept both 3 and 5 digit formats with '3+5'", () => {
-      const schema = postalCode({ format: "3+5" })
+      const schema = postalCode(true, { format: "3+5" })
       expect(schema.parse("100")).toBe("100")
       expect(schema.parse("10001")).toBe("10001")
       expect(() => schema.parse("100001")).toThrow("Invalid Taiwan postal code")
@@ -127,14 +127,14 @@ describe("postalCode() features", () => {
     })
 
     it("should accept both 5 and 6 digit formats with '5+6'", () => {
-      const schema = postalCode({ format: "5+6" })
+      const schema = postalCode(true, { format: "5+6" })
       expect(schema.parse("10001")).toBe("10001")
       expect(schema.parse("100001")).toBe("100001")
       expect(() => schema.parse("100")).toThrow("Invalid Taiwan postal code")
     })
 
     it("should accept all formats with 'all'", () => {
-      const schema = postalCode({ format: "all" })
+      const schema = postalCode(true, { format: "all" })
       expect(schema.parse("100")).toBe("100")
       expect(schema.parse("10001")).toBe("10001")
       expect(schema.parse("100001")).toBe("100001")
@@ -143,7 +143,7 @@ describe("postalCode() features", () => {
 
   describe("dash and space handling", () => {
     it("should handle dashes in postal codes when allowDashes is true", () => {
-      const schema = postalCode({ format: "all", allowDashes: true })
+      const schema = postalCode(true, { format: "all", allowDashes: true })
       expect(schema.parse("100")).toBe("100")
       expect(schema.parse("100-01")).toBe("10001")
       expect(schema.parse("100-001")).toBe("100001")
@@ -151,14 +151,14 @@ describe("postalCode() features", () => {
     })
 
     it("should reject dashes when allowDashes is false", () => {
-      const schema = postalCode({ format: "all", allowDashes: false })
+      const schema = postalCode(true, { format: "all", allowDashes: false })
       expect(schema.parse("100")).toBe("100")
       expect(() => schema.parse("100-01")).toThrow("Invalid Taiwan postal code")
       expect(() => schema.parse("100-001")).toThrow("Invalid Taiwan postal code")
     })
 
     it("should normalize various dash and space formats", () => {
-      const schema = postalCode({ format: "6", allowDashes: true })
+      const schema = postalCode(true, { format: "6", allowDashes: true })
       expect(schema.parse("100-001")).toBe("100001")
       expect(schema.parse("100 001")).toBe("100001")
       expect(schema.parse("100   001")).toBe("100001")
@@ -168,9 +168,9 @@ describe("postalCode() features", () => {
 
   describe("prefix filtering", () => {
     it("should only allow specified prefixes", () => {
-      const schema = postalCode({
+      const schema = postalCode(true, {
         format: "all",
-        allowedPrefixes: ["100", "200", "300"]
+        allowedPrefixes: ["100", "200", "300"],
       })
       expect(schema.parse("100")).toBe("100")
       expect(schema.parse("10001")).toBe("10001")
@@ -181,9 +181,9 @@ describe("postalCode() features", () => {
     })
 
     it("should block specified prefixes", () => {
-      const schema = postalCode({
+      const schema = postalCode(true, {
         format: "all",
-        blockedPrefixes: ["999", "000"]
+        blockedPrefixes: ["999", "000"],
       })
       expect(schema.parse("100")).toBe("100")
       expect(() => schema.parse("999")).toThrow("Invalid Taiwan postal code")
@@ -192,19 +192,19 @@ describe("postalCode() features", () => {
     })
 
     it("should prioritize allowedPrefixes over strict validation", () => {
-      const schema = postalCode({
+      const schema = postalCode(true, {
         format: "3",
         allowedPrefixes: ["999"], // Not in official list
-        strictValidation: true
+        strictValidation: true,
       })
       expect(schema.parse("999")).toBe("999")
     })
 
     it("should respect blockedPrefixes even with allowedPrefixes", () => {
-      const schema = postalCode({
+      const schema = postalCode(true, {
         format: "3",
         allowedPrefixes: ["100", "200", "999"],
-        blockedPrefixes: ["999"]
+        blockedPrefixes: ["999"],
       })
       expect(schema.parse("100")).toBe("100")
       expect(schema.parse("200")).toBe("200")
@@ -214,20 +214,20 @@ describe("postalCode() features", () => {
 
   describe("strict validation", () => {
     it("should validate against official postal code list when strict", () => {
-      const schema = postalCode({ format: "3", strictValidation: true })
+      const schema = postalCode(true, { format: "3", strictValidation: true })
       expect(schema.parse("100")).toBe("100") // Valid official code
       expect(() => schema.parse("199")).toThrow("Invalid Taiwan postal code") // Not in official list
     })
 
     it("should allow broader range when not strict", () => {
-      const schema = postalCode({ format: "3", strictValidation: false })
+      const schema = postalCode(true, { format: "3", strictValidation: false })
       expect(schema.parse("100")).toBe("100") // Valid official code
       expect(schema.parse("199")).toBe("199") // Not in official list but in range 100-999
       expect(() => schema.parse("099")).toThrow("Invalid Taiwan postal code") // Still below 100
     })
 
     it("should validate all Taiwan regions with strict validation", () => {
-      const schema = postalCode({ format: "3", strictValidation: true })
+      const schema = postalCode(true, { format: "3", strictValidation: true })
 
       // Major cities
       expect(schema.parse("100")).toBe("100") // Taipei City
@@ -254,28 +254,28 @@ describe("postalCode() features", () => {
 
   describe("required and optional validation", () => {
     it("should handle required validation", () => {
-      const schema = postalCode()
+      const schema = postalCode(true)
       expect(() => schema.parse(null)).toThrow("Required")
       expect(() => schema.parse(undefined)).toThrow("Required")
       expect(() => schema.parse("")).toThrow("Required")
     })
 
     it("should allow null when not required", () => {
-      const schema = postalCode({ required: false })
+      const schema = postalCode(false)
       expect(schema.parse(null)).toBe(null)
       expect(schema.parse(undefined)).toBe(null)
       expect(schema.parse("")).toBe(null)
     })
 
     it("should use default value when provided", () => {
-      const schema = postalCode({ defaultValue: "100001" })
+      const schema = postalCode(true, { defaultValue: "100001" })
       expect(schema.parse("")).toBe("100001")
       expect(schema.parse(null)).toBe("100001")
       expect(schema.parse(undefined)).toBe("100001")
     })
 
     it("should use default value for optional fields", () => {
-      const schema = postalCode({ required: false, defaultValue: "100001" })
+      const schema = postalCode(false, { defaultValue: "100001" })
       expect(schema.parse("")).toBe("100001")
       expect(schema.parse(null)).toBe("100001")
       expect(schema.parse(undefined)).toBe("100001")
@@ -284,9 +284,9 @@ describe("postalCode() features", () => {
 
   describe("transform functionality", () => {
     it("should apply transform function", () => {
-      const schema = postalCode({
+      const schema = postalCode(true, {
         format: "6",
-        transform: (val) => val.replace(/\D/g, "") // Remove non-digits
+        transform: (val) => val.replace(/\D/g, ""), // Remove non-digits
       })
       expect(schema.parse("100-001")).toBe("100001")
       expect(schema.parse("100.001")).toBe("100001")
@@ -294,10 +294,10 @@ describe("postalCode() features", () => {
     })
 
     it("should apply transform after dash removal", () => {
-      const schema = postalCode({
+      const schema = postalCode(true, {
         format: "3",
         allowDashes: true,
-        transform: (val) => val.padEnd(3, "0") // Pad to 3 digits
+        transform: (val) => val.padEnd(3, "0"), // Pad to 3 digits
       })
       expect(schema.parse("10")).toBe("100")
       expect(schema.parse("1")).toBe("100")
@@ -306,8 +306,8 @@ describe("postalCode() features", () => {
 
   describe("legacy 5-digit warning", () => {
     it("should emit warning for 5-digit codes when warn5Digit is true", () => {
-      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-      const schema = postalCode({ format: "all", warn5Digit: true })
+      const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+      const schema = postalCode(true, { format: "all", warn5Digit: true })
 
       schema.parse("10001") // Should emit warning
       expect(consoleSpy).toHaveBeenCalledWith("5-digit postal codes are legacy format, consider using 6-digit format")
@@ -319,8 +319,8 @@ describe("postalCode() features", () => {
     })
 
     it("should not emit warning when warn5Digit is false", () => {
-      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-      const schema = postalCode({ format: "all", warn5Digit: false })
+      const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+      const schema = postalCode(true, { format: "all", warn5Digit: false })
 
       schema.parse("10001") // Should not emit warning
       expect(consoleSpy).not.toHaveBeenCalled()
@@ -329,8 +329,8 @@ describe("postalCode() features", () => {
     })
 
     it("should not emit warning for 5-digit only format", () => {
-      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-      const schema = postalCode({ format: "5", warn5Digit: true })
+      const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+      const schema = postalCode(true, { format: "5", warn5Digit: true })
 
       schema.parse("10001") // Should not emit warning for 5-digit only format
       expect(consoleSpy).not.toHaveBeenCalled()
@@ -341,7 +341,7 @@ describe("postalCode() features", () => {
 
   describe("custom i18n messages", () => {
     it("should use custom messages when provided", () => {
-      const schema = postalCode({
+      const schema = postalCode(true, {
         format: "3",
         i18n: {
           en: {
@@ -363,7 +363,7 @@ describe("postalCode() features", () => {
     })
 
     it("should fallback to default messages when custom not provided", () => {
-      const schema = postalCode({
+      const schema = postalCode(true, {
         format: "6",
         i18n: {
           en: {
@@ -381,7 +381,7 @@ describe("postalCode() features", () => {
 
     it("should use correct locale for custom messages", () => {
       setLocale("en")
-      const schemaEn = postalCode({
+      const schemaEn = postalCode(true, {
         format: "3",
         i18n: {
           en: {
@@ -395,7 +395,7 @@ describe("postalCode() features", () => {
       expect(() => schemaEn.parse("999")).toThrow("English invalid message")
 
       setLocale("zh-TW")
-      const schemaZh = postalCode({
+      const schemaZh = postalCode(true, {
         format: "3",
         i18n: {
           en: {
@@ -412,12 +412,12 @@ describe("postalCode() features", () => {
 
   describe("complex scenarios", () => {
     it("should work with multiple validations", () => {
-      const schema = postalCode({
+      const schema = postalCode(true, {
         format: "6",
         allowDashes: true,
         strictValidation: true,
         allowedPrefixes: ["100", "200", "300"],
-        transform: (val) => val.replace(/\D/g, "").padEnd(6, "0")
+        transform: (val) => val.replace(/\D/g, "").padEnd(6, "0"),
       })
 
       expect(schema.parse("100-001")).toBe("100001")
@@ -429,10 +429,10 @@ describe("postalCode() features", () => {
     })
 
     it("should handle edge cases with transforms and dashes", () => {
-      const schema = postalCode({
+      const schema = postalCode(true, {
         format: "all",
         allowDashes: true,
-        transform: (val) => val.toUpperCase().replace(/[^0-9-]/g, "")
+        transform: (val) => val.toUpperCase().replace(/[^0-9-]/g, ""),
       })
 
       expect(schema.parse("100ABC-001DEF")).toBe("100001")
@@ -441,57 +441,103 @@ describe("postalCode() features", () => {
     })
 
     it("should validate comprehensive Taiwan postal code coverage", () => {
-      const schema = postalCode({ format: "all", strictValidation: true })
+      const schema = postalCode(true, { format: "all", strictValidation: true })
 
       // Test various regions
       const validCodes = [
         // Taipei area
-        "100", "103", "104", "105", "106", "108", "110", "111", "112", "114", "115", "116",
-        "10001", "10301", "100001", "103001",
+        "100",
+        "103",
+        "104",
+        "105",
+        "106",
+        "108",
+        "110",
+        "111",
+        "112",
+        "114",
+        "115",
+        "116",
+        "10001",
+        "10301",
+        "100001",
+        "103001",
 
         // New Taipei area
-        "220", "221", "222", "223", "224", "226", "227", "228",
-        "22001", "221001",
+        "220",
+        "221",
+        "222",
+        "223",
+        "224",
+        "226",
+        "227",
+        "228",
+        "22001",
+        "221001",
 
         // Taoyuan area
-        "320", "324", "325", "326", "327", "328", "330", "333",
-        "32001", "320001",
+        "320",
+        "324",
+        "325",
+        "326",
+        "327",
+        "328",
+        "330",
+        "333",
+        "32001",
+        "320001",
 
         // Offshore islands
-        "880", "881", "882", "883", "884", "885", // Penghu
-        "890", "891", "892", "893", "894", "895", "896", // Kinmen
-        "209", "210", "211", "212", // Lienchiang (Matsu)
-        "88001", "890001", "209001"
+        "880",
+        "881",
+        "882",
+        "883",
+        "884",
+        "885", // Penghu
+        "890",
+        "891",
+        "892",
+        "893",
+        "894",
+        "895",
+        "896", // Kinmen
+        "209",
+        "210",
+        "211",
+        "212", // Lienchiang (Matsu)
+        "88001",
+        "890001",
+        "209001",
       ]
 
-      validCodes.forEach(code => {
+      validCodes.forEach((code) => {
         expect(schema.parse(code)).toBe(code)
       })
     })
 
     it("should work with real-world postal codes", () => {
-      const schema = postalCode({ format: "all", allowDashes: true })
+      const schema = postalCode(true, { format: "all", allowDashes: true })
 
       // Real Taiwan postal codes
-      expect(schema.parse("100")).toBe("100")        // Taipei Main Post Office
-      expect(schema.parse("110")).toBe("110")        // Xinyi District, Taipei
-      expect(schema.parse("220")).toBe("220")        // Banqiao District, New Taipei
-      expect(schema.parse("300")).toBe("300")        // East District, Hsinchu City
-      expect(schema.parse("400")).toBe("400")        // Central District, Taichung
-      expect(schema.parse("700")).toBe("700")        // Central District, Tainan
-      expect(schema.parse("800")).toBe("800")        // Xinxing District, Kaohsiung
-      expect(schema.parse("880")).toBe("880")        // Magong City, Penghu
-      expect(schema.parse("890")).toBe("890")        // Jincheng Township, Kinmen
+      expect(schema.parse("100")).toBe("100") // Taipei Main Post Office
+      expect(schema.parse("110")).toBe("110") // Xinyi District, Taipei
+      expect(schema.parse("220")).toBe("220") // Banqiao District, New Taipei
+      expect(schema.parse("300")).toBe("300") // East District, Hsinchu City
+      expect(schema.parse("400")).toBe("400") // Central District, Taichung
+      expect(schema.parse("700")).toBe("700") // Central District, Tainan
+      expect(schema.parse("800")).toBe("800") // Xinxing District, Kaohsiung
+      expect(schema.parse("880")).toBe("880") // Magong City, Penghu
+      expect(schema.parse("890")).toBe("890") // Jincheng Township, Kinmen
 
       // With dashes
-      expect(schema.parse("100-01")).toBe("10001")   // 5-digit format
+      expect(schema.parse("100-01")).toBe("10001") // 5-digit format
       expect(schema.parse("100-001")).toBe("100001") // 6-digit format
     })
   })
 
   describe("strict suffix validation with regional ranges", () => {
     it("should validate 5-digit suffix ranges for major cities", () => {
-      const schema = postalCode({ format: "5", strictSuffixValidation: true })
+      const schema = postalCode(true, { format: "5", strictSuffixValidation: true })
       // Taipei areas (full range 01-99)
       expect(schema.parse("10001")).toBe("10001") // Valid suffix 01
       expect(schema.parse("10099")).toBe("10099") // Valid suffix 99
@@ -500,7 +546,7 @@ describe("postalCode() features", () => {
     })
 
     it("should validate 6-digit suffix ranges for major cities", () => {
-      const schema = postalCode({ format: "6", strictSuffixValidation: true })
+      const schema = postalCode(true, { format: "6", strictSuffixValidation: true })
       // Taipei areas (full range 001-999)
       expect(schema.parse("100001")).toBe("100001") // Valid suffix 001
       expect(schema.parse("100999")).toBe("100999") // Valid suffix 999
@@ -509,7 +555,7 @@ describe("postalCode() features", () => {
     })
 
     it("should validate restricted ranges for smaller areas", () => {
-      const schema = postalCode({ format: "all", strictSuffixValidation: true })
+      const schema = postalCode(true, { format: "all", strictSuffixValidation: true })
 
       // Penghu (limited range)
       expect(schema.parse("88001")).toBe("88001") // Valid for Penghu
@@ -531,7 +577,7 @@ describe("postalCode() features", () => {
     })
 
     it("should allow any suffix when strictSuffixValidation is disabled", () => {
-      const schema = postalCode({ format: "all", strictSuffixValidation: false })
+      const schema = postalCode(true, { format: "all", strictSuffixValidation: false })
       expect(schema.parse("10000")).toBe("10000") // Suffix 00 allowed
       expect(schema.parse("100000")).toBe("100000") // Suffix 000 allowed
       expect(schema.parse("10099")).toBe("10099") // Normal suffix
@@ -540,24 +586,24 @@ describe("postalCode() features", () => {
 
   describe("5-digit deprecation", () => {
     it("should reject 5-digit codes when deprecate5Digit is enabled", () => {
-      const schema = postalCode({ format: "all", deprecate5Digit: true })
+      const schema = postalCode(true, { format: "all", deprecate5Digit: true })
       expect(schema.parse("100")).toBe("100") // 3-digit still allowed
       expect(schema.parse("100001")).toBe("100001") // 6-digit still allowed
       expect(() => schema.parse("10001")).toThrow("5-digit postal codes are deprecated") // 5-digit rejected
     })
 
     it("should allow 5-digit codes when deprecate5Digit is disabled", () => {
-      const schema = postalCode({ format: "all", deprecate5Digit: false })
+      const schema = postalCode(true, { format: "all", deprecate5Digit: false })
       expect(schema.parse("10001")).toBe("10001") // 5-digit allowed
     })
   })
 
   describe("combined strict validation scenarios", () => {
     it("should work with both strictSuffixValidation and deprecate5Digit", () => {
-      const schema = postalCode({
+      const schema = postalCode(true, {
         format: "6",
         strictSuffixValidation: true,
-        deprecate5Digit: true
+        deprecate5Digit: true,
       })
       expect(schema.parse("100001")).toBe("100001") // Valid 6-digit
       expect(() => schema.parse("100000")).toThrow("Invalid postal code suffix") // Invalid suffix
@@ -565,10 +611,10 @@ describe("postalCode() features", () => {
     })
 
     it("should provide specific error for real-world validation scenarios", () => {
-      const realWorldSchema = postalCode({
+      const realWorldSchema = postalCode(true, {
         format: "6",
         strictSuffixValidation: true,
-        strictValidation: true
+        strictValidation: true,
       })
 
       // Valid real postal codes from major cities
@@ -598,11 +644,11 @@ describe("postalCode() features", () => {
 
   describe("regional-specific validation", () => {
     it("should validate major cities with full ranges", () => {
-      const schema = postalCode({ format: "all", strictSuffixValidation: true })
+      const schema = postalCode(true, { format: "all", strictSuffixValidation: true })
 
       // Taipei City areas - should have full 01-99 and 001-999 ranges
       const taipeiAreas = ["100", "103", "104", "105", "106", "108", "110", "111", "112", "114", "115", "116"]
-      taipeiAreas.forEach(area => {
+      taipeiAreas.forEach((area) => {
         expect(schema.parse(`${area}01`)).toBe(`${area}01`) // Min 5-digit
         expect(schema.parse(`${area}99`)).toBe(`${area}99`) // Max 5-digit
         expect(schema.parse(`${area}001`)).toBe(`${area}001`) // Min 6-digit
@@ -617,7 +663,7 @@ describe("postalCode() features", () => {
     })
 
     it("should enforce restricted ranges for offshore islands", () => {
-      const schema = postalCode({ format: "all", strictSuffixValidation: true })
+      const schema = postalCode(true, { format: "all", strictSuffixValidation: true })
 
       // Penghu County (880) - limited to 01-50 and 001-500
       expect(schema.parse("88001")).toBe("88001")
@@ -645,7 +691,7 @@ describe("postalCode() features", () => {
     })
 
     it("should use default ranges for areas not in specific mapping", () => {
-      const schema = postalCode({ format: "all", strictSuffixValidation: true })
+      const schema = postalCode(true, { format: "all", strictSuffixValidation: true })
 
       // Areas not specifically mapped should use default ranges (01-99, 001-999)
       expect(schema.parse("26001")).toBe("26001") // Yilan - uses default
@@ -659,7 +705,7 @@ describe("postalCode() features", () => {
 
   describe("edge cases", () => {
     it("should handle empty and whitespace inputs", () => {
-      const schema = postalCode({ required: false })
+      const schema = postalCode(false)
       expect(schema.parse("")).toBe(null)
       expect(schema.parse("   ")).toBe(null)
       expect(schema.parse("\t")).toBe(null)
@@ -667,22 +713,22 @@ describe("postalCode() features", () => {
     })
 
     it("should handle numeric inputs", () => {
-      const schema = postalCode({ format: "3" })
+      const schema = postalCode(true, { format: "3" })
       expect(schema.parse(100)).toBe("100")
       expect(schema.parse(200)).toBe("200")
     })
 
     it("should reject codes with letters when not using transform", () => {
-      const schema = postalCode({ format: "3", allowDashes: false })
+      const schema = postalCode(true, { format: "3", allowDashes: false })
       expect(() => schema.parse("10A")).toThrow("Invalid Taiwan postal code")
       expect(() => schema.parse("ABC")).toThrow("Invalid Taiwan postal code")
     })
 
     it("should handle very specific area restrictions", () => {
       // Only allow Taipei city areas
-      const taipeiOnlySchema = postalCode({
+      const taipeiOnlySchema = postalCode(true, {
         format: "all",
-        allowedPrefixes: ["100", "103", "104", "105", "106", "108", "110", "111", "112", "114", "115", "116"]
+        allowedPrefixes: ["100", "103", "104", "105", "106", "108", "110", "111", "112", "114", "115", "116"],
       })
 
       expect(taipeiOnlySchema.parse("100")).toBe("100")
@@ -691,15 +737,15 @@ describe("postalCode() features", () => {
     })
 
     it("should handle format combinations correctly", () => {
-      const schema35 = postalCode({ format: "3+5" })
+      const schema35 = postalCode(true, { format: "3+5" })
       expect(schema35.parse("100")).toBe("100")
       expect(schema35.parse("10001")).toBe("10001")
       expect(() => schema35.parse("100001")).toThrow("Invalid Taiwan postal code")
 
-      const schema56 = postalCode({ format: "5+6" })
+      const schema56 = postalCode(true, { format: "5+6" })
       expect(schema56.parse("10001")).toBe("10001")
       expect(schema56.parse("100001")).toBe("100001")
       expect(() => schema56.parse("100")).toThrow("Invalid Taiwan postal code")
     })
   })
-})
+})