@hy_ong/zod-kit 0.0.5 → 0.1.0

package/tests/common/password.test.ts

@@ -42,31 +42,31 @@ const locales = [
   },
 ] as const
 
-describe.each(locales)("password() locale: $locale", ({ locale, messages }) => {
+describe.each(locales)("password(true) locale: $locale", ({ locale, messages }) => {
   beforeEach(() => setLocale(locale as Locale))
 
   describe("basic functionality", () => {
     it("should pass with valid string", () => {
-      const schema = password()
+      const schema = password(true)
       expect(schema.parse("hello")).toBe("hello")
     })
 
     it("should fail with empty string when required", () => {
-      const schema = password()
+      const schema = password(true)
       expect(() => schema.parse("")).toThrow(messages.required)
       expect(() => schema.parse(null)).toThrow(messages.required)
       expect(() => schema.parse(undefined)).toThrow(messages.required)
     })
 
     it("should pass with null when not required", () => {
-      const schema = password({ required: false })
+      const schema = password(false)
       expect(schema.parse("")).toBe(null)
       expect(schema.parse(null)).toBe(null)
       expect(schema.parse(undefined)).toBe(null)
     })
 
     it("should handle default values", () => {
-      const schema = password({ required: false, defaultValue: "default123" })
+      const schema = password(false, { defaultValue: "default123" })
       expect(schema.parse("")).toBe("default123")
       expect(schema.parse(null)).toBe("default123")
       expect(schema.parse(undefined)).toBe("default123")
@@ -74,55 +74,55 @@ describe.each(locales)("password() locale: $locale", ({ locale, messages }) => {
     })
 
     it("should apply transform function", () => {
-      const schema = password({ transform: (val) => val.toLowerCase() })
+      const schema = password(true, { transform: (val) => val.toLowerCase() })
       expect(schema.parse("HELLO")).toBe("hello")
     })
   })
 
   describe("length validation", () => {
     it("should fail with string shorter than min", () => {
-      const schema = password({ min: 8 })
+      const schema = password(true, { min: 8 })
       expect(() => schema.parse("short")).toThrow(messages.min)
     })
 
     it("should fail with string longer than max", () => {
-      const schema = password({ max: 20 })
+      const schema = password(true, { max: 20 })
       expect(() => schema.parse("this_is_a_very_long_password_that_exceeds_limit")).toThrow(messages.max)
     })
 
     it("should pass with valid length", () => {
-      const schema = password({ min: 5, max: 15 })
+      const schema = password(true, { min: 5, max: 15 })
       expect(schema.parse("validpassword")).toBe("validpassword")
     })
   })
 
   describe("character requirements", () => {
     it("should enforce uppercase requirement", () => {
-      const schema = password({ uppercase: true })
+      const schema = password(true, { uppercase: true })
       expect(() => schema.parse("lowercase1!")).toThrow(messages.uppercase)
       expect(schema.parse("Hello1!")).toBe("Hello1!")
     })
 
     it("should enforce lowercase requirement", () => {
-      const schema = password({ lowercase: true })
+      const schema = password(true, { lowercase: true })
       expect(() => schema.parse("UPPERCASE1!")).toThrow(messages.lowercase)
       expect(schema.parse("Test1!")).toBe("Test1!")
     })
 
     it("should enforce digit requirement", () => {
-      const schema = password({ digits: true })
+      const schema = password(true, { digits: true })
       expect(() => schema.parse("NoDigits!")).toThrow(messages.digits)
       expect(schema.parse("With1!")).toBe("With1!")
     })
 
     it("should enforce special character requirement", () => {
-      const schema = password({ special: true })
+      const schema = password(true, { special: true })
       expect(() => schema.parse("NoSpecial1")).toThrow(messages.special)
       expect(schema.parse("Valid1!")).toBe("Valid1!")
     })
 
     it("should enforce multiple requirements", () => {
-      const schema = password({ uppercase: true, lowercase: true, digits: true, special: true })
+      const schema = password(true, { uppercase: true, lowercase: true, digits: true, special: true })
       expect(() => schema.parse("nouppercase1!")).toThrow(messages.uppercase)
       expect(() => schema.parse("NOLOWERCASE1!")).toThrow(messages.lowercase)
       expect(() => schema.parse("NoDigits!")).toThrow(messages.digits)
@@ -133,14 +133,14 @@ describe.each(locales)("password() locale: $locale", ({ locale, messages }) => {
 
   describe("advanced security features", () => {
     it("should enforce no repeating characters", () => {
-      const schema = password({ noRepeating: true })
+      const schema = password(true, { noRepeating: true })
       expect(() => schema.parse("password111")).toThrow(messages.noRepeating)
       expect(() => schema.parse("helllo")).toThrow(messages.noRepeating)
       expect(schema.parse("password")).toBe("password")
     })
 
     it("should enforce no sequential characters", () => {
-      const schema = password({ noSequential: true })
+      const schema = password(true, { noSequential: true })
       expect(() => schema.parse("abc123")).toThrow(messages.noSequential)
       expect(() => schema.parse("xyz789")).toThrow(messages.noSequential)
       expect(() => schema.parse("password456")).toThrow(messages.noSequential)
@@ -148,7 +148,7 @@ describe.each(locales)("password() locale: $locale", ({ locale, messages }) => {
     })
 
     it("should enforce no common words", () => {
-      const schema = password({ noCommonWords: true })
+      const schema = password(true, { noCommonWords: true })
       expect(() => schema.parse("password123")).toThrow(messages.noCommonWords)
       expect(() => schema.parse("admin")).toThrow(messages.noCommonWords)
       expect(() => schema.parse("qwerty")).toThrow(messages.noCommonWords)
@@ -156,7 +156,7 @@ describe.each(locales)("password() locale: $locale", ({ locale, messages }) => {
     })
 
     it("should enforce minimum strength", () => {
-      const schema = password({ minStrength: "strong" })
+      const schema = password(true, { minStrength: "strong" })
       expect(() => schema.parse("weak")).toThrow(messages.minStrength)
       expect(() => schema.parse("123456")).toThrow(messages.minStrength)
       expect(schema.parse("StrongP@ssw0rd")).toBe("StrongP@ssw0rd")
@@ -165,26 +165,26 @@ describe.each(locales)("password() locale: $locale", ({ locale, messages }) => {
 
   describe("content validation", () => {
     it("should enforce includes requirement", () => {
-      const schema = password({ includes: "@" })
+      const schema = password(true, { includes: "@" })
       expect(() => schema.parse("password")).toThrow(messages.includes)
       expect(schema.parse("user@pass")).toBe("user@pass")
     })
 
     it("should enforce excludes requirement with string", () => {
-      const schema = password({ excludes: "test" })
+      const schema = password(true, { excludes: "test" })
       expect(() => schema.parse("testpassword")).toThrow(messages.excludes)
       expect(schema.parse("password")).toBe("password")
     })
 
     it("should enforce excludes requirement with array", () => {
-      const schema = password({ excludes: ["test", "admin"] })
+      const schema = password(true, { excludes: ["test", "admin"] })
       expect(() => schema.parse("testpassword")).toThrow()
       expect(() => schema.parse("adminpass")).toThrow()
       expect(schema.parse("password")).toBe("password")
     })
 
     it("should enforce regex requirement", () => {
-      const schema = password({ regex: /^[a-zA-Z0-9!@#$%^&*()]+$/ })
+      const schema = password(true, { regex: /^[a-zA-Z0-9!@#$%^&*()]+$/ })
       expect(() => schema.parse("invalid-password")).toThrow(messages.invalid)
       expect(schema.parse("Valid123!")).toBe("Valid123!")
     })
@@ -205,7 +205,7 @@ describe.each(locales)("password() locale: $locale", ({ locale, messages }) => {
         },
       }
 
-      const schema = password({
+      const schema = password(true, {
         min: 8,
         uppercase: true,
         i18n: customMessages,
@@ -228,7 +228,7 @@ describe.each(locales)("password() locale: $locale", ({ locale, messages }) => {
         "zh-TW": { required: "自訂必填訊息" },
       }
 
-      const schema = password({
+      const schema = password(true, {
         uppercase: true,
         i18n: customMessages,
       })
@@ -245,7 +245,7 @@ describe.each(locales)("password() locale: $locale", ({ locale, messages }) => {
 
   describe("complex scenarios", () => {
     it("should handle all features combined", () => {
-      const schema = password({
+      const schema = password(true, {
         min: 12,
         max: 50,
         uppercase: true,
@@ -277,14 +277,7 @@ describe.each(locales)("password() locale: $locale", ({ locale, messages }) => {
     })
 
     it("should work with optional password and all features", () => {
-      const schema = password({
-        required: false,
-        min: 8,
-        uppercase: true,
-        lowercase: true,
-        digits: true,
-        special: true,
-      })
+      const schema = password(false, { min: 8, uppercase: true, lowercase: true, digits: true, special: true })
 
       expect(schema.parse(null)).toBe(null)
       expect(schema.parse("")).toBe(null)
@@ -303,7 +296,7 @@ describe.each(locales)("password() locale: $locale", ({ locale, messages }) => {
 
     testStrengthScenarios.forEach(({ password: testPassword, expectedToPass, minStrength }) => {
       it(`should ${expectedToPass ? "pass" : "fail"} for password "${testPassword}" with minStrength "${minStrength}"`, () => {
-        const schema = password({ minStrength })
+        const schema = password(true, { minStrength })
 
         if (expectedToPass) {
           expect(schema.parse(testPassword)).toBe(testPassword)
@@ -313,4 +306,4 @@ describe.each(locales)("password() locale: $locale", ({ locale, messages }) => {
       })
     })
   })
-})
+})

package/tests/common/text.test.ts

@@ -32,30 +32,30 @@ const locales = [
   },
 ] as const
 
-describe.each(locales)("text() locale: $locale", ({ locale, messages }) => {
+describe.each(locales)("text(true) locale: $locale", ({ locale, messages }) => {
   beforeEach(() => setLocale(locale as Locale))
 
   it("should pass with valid string", () => {
-    const schema = text()
+    const schema = text(true)
     expect(schema.parse("hello")).toBe("hello")
   })
 
   it("should fail with empty string when required", () => {
-    const schema = text()
+    const schema = text(true)
     expect(() => schema.parse("")).toThrow(messages.required)
     expect(() => schema.parse(null)).toThrow(messages.required)
     expect(() => schema.parse(undefined)).toThrow(messages.required)
   })
 
   it("should pass with null when not required", () => {
-    const schema = text({ required: false })
+    const schema = text(false)
     expect(schema.parse("")).toBe(null)
     expect(schema.parse(null)).toBe(null)
     expect(schema.parse(undefined)).toBe(null)
   })
 
   it("should fail with string shorter than minLength", () => {
-    const schema = text({ minLength: 5 })
+    const schema = text(true, { minLength: 5 })
     expect(() => schema.parse("hi")).toThrow(messages.minLength)
     expect(() => schema.parse("")).toThrow(messages.required) // Empty string triggers required first
     expect(() => schema.parse(null)).toThrow(messages.required) // Null triggers required first
@@ -63,42 +63,42 @@ describe.each(locales)("text() locale: $locale", ({ locale, messages }) => {
   })
 
   it("should fail with string longer than maxLength", () => {
-    const schema = text({ maxLength: 5 })
+    const schema = text(true, { maxLength: 5 })
     expect(() => schema.parse("hello world")).toThrow(messages.maxLength)
   })
 
   it("should fail if does not start with specified string", () => {
-    const schema = text({ startsWith: "pre" })
+    const schema = text(true, { startsWith: "pre" })
     expect(schema.parse("prepaid")).toBe("prepaid")
     expect(() => schema.parse("hello world")).toThrow(messages.startsWith)
   })
 
   it("should fail if does not end with specified string", () => {
-    const schema = text({ endsWith: "xyz" })
+    const schema = text(true, { endsWith: "xyz" })
     expect(schema.parse("hello xyz")).toBe("hello xyz")
     expect(() => schema.parse("hello world")).toThrow(messages.endsWith)
   })
 
   it("should fail if does not include specified substring", () => {
-    const schema = text({ includes: "foo" })
+    const schema = text(true, { includes: "foo" })
     expect(schema.parse("hello foo")).toBe("hello foo")
     expect(() => schema.parse("hello world")).toThrow(messages.includes)
   })
 
   it("should fail if does not match regex", () => {
-    const schema = text({ regex: /^[A-Z]+$/ })
+    const schema = text(true, { regex: /^[A-Z]+$/ })
     expect(schema.parse("HELLO")).toBe("HELLO")
     expect(() => schema.parse("hello")).toThrow(messages.invalid)
   })
 
   it("should fail if contains excluded substring", () => {
-    const schema = text({ excludes: "admin" })
+    const schema = text(true, { excludes: "admin" })
     expect(schema.parse("hello")).toBe("hello")
     expect(() => schema.parse("admin user")).toThrow(messages.excludes)
   })
 
   it("should fail if contains any excluded substring from array", () => {
-    const schema = text({ excludes: ["admin", "root", "test"] })
+    const schema = text(true, { excludes: ["admin", "root", "test"] })
     expect(schema.parse("hello")).toBe("hello")
     expect(() => schema.parse("admin user")).toThrow(/Must not contain|不得包含/)
     expect(() => schema.parse("root access")).toThrow(/Must not contain|不得包含/)
@@ -106,68 +106,68 @@ describe.each(locales)("text() locale: $locale", ({ locale, messages }) => {
   })
 
   it("should fail with notEmpty when only whitespace", () => {
-    const schema = text({ notEmpty: true, trimMode: "none" })
+    const schema = text(true, { notEmpty: true, trimMode: "none" })
     expect(schema.parse("hello")).toBe("hello")
     expect(() => schema.parse("   ")).toThrow(messages.notEmpty)
     expect(() => schema.parse("\t\n")).toThrow(messages.notEmpty)
   })
 })
 
-describe("text() trimMode functionality", () => {
+describe("text(true) trimMode functionality", () => {
   it("should trim by default", () => {
-    const schema = text()
+    const schema = text(true)
     expect(schema.parse("  hello  ")).toBe("hello")
   })
 
   it("should trim start only", () => {
-    const schema = text({ trimMode: "trimStart" })
+    const schema = text(true, { trimMode: "trimStart" })
     expect(schema.parse("  hello  ")).toBe("hello  ")
   })
 
   it("should trim end only", () => {
-    const schema = text({ trimMode: "trimEnd" })
+    const schema = text(true, { trimMode: "trimEnd" })
     expect(schema.parse("  hello  ")).toBe("  hello")
   })
 
   it("should not trim when mode is none", () => {
-    const schema = text({ trimMode: "none" })
+    const schema = text(true, { trimMode: "none" })
     expect(schema.parse("  hello  ")).toBe("  hello  ")
   })
 })
 
-describe("text() casing functionality", () => {
+describe("text(true) casing functionality", () => {
   it("should convert to uppercase", () => {
-    const schema = text({ casing: "upper" })
+    const schema = text(true, { casing: "upper" })
     expect(schema.parse("hello world")).toBe("HELLO WORLD")
   })
 
   it("should convert to lowercase", () => {
-    const schema = text({ casing: "lower" })
+    const schema = text(true, { casing: "lower" })
     expect(schema.parse("HELLO WORLD")).toBe("hello world")
   })
 
   it("should convert to title case", () => {
-    const schema = text({ casing: "title" })
+    const schema = text(true, { casing: "title" })
     expect(schema.parse("hello world")).toBe("Hello World")
     expect(schema.parse("HELLO WORLD")).toBe("Hello World")
   })
 
   it("should not change casing when none", () => {
-    const schema = text({ casing: "none" })
+    const schema = text(true, { casing: "none" })
     expect(schema.parse("Hello World")).toBe("Hello World")
   })
 })
 
-describe("text() transform functionality", () => {
+describe("text(true) transform functionality", () => {
   it("should apply custom transform function", () => {
-    const schema = text({
+    const schema = text(true, {
       transform: (val) => val.replace(/\s+/g, "-"),
     })
     expect(schema.parse("hello world test")).toBe("hello-world-test")
   })
 
   it("should apply transform after trimming and casing", () => {
-    const schema = text({
+    const schema = text(true, {
       trimMode: "trim",
       casing: "lower",
       transform: (val) => val.replace(/\s+/g, "_"),
@@ -176,27 +176,27 @@ describe("text() transform functionality", () => {
   })
 })
 
-describe("text() defaultValue functionality", () => {
+describe("text(true) defaultValue functionality", () => {
   it("should use defaultValue for empty input when required", () => {
-    const schema = text({ defaultValue: "default" })
+    const schema = text(true, { defaultValue: "default" })
     expect(schema.parse("")).toBe("default")
     expect(schema.parse(null)).toBe("default")
     expect(schema.parse(undefined)).toBe("default")
   })
 
   it("should use defaultValue for empty input when not required", () => {
-    const schema = text({ required: false, defaultValue: "default" })
+    const schema = text(false, { defaultValue: "default" })
     expect(schema.parse("")).toBe("default")
     expect(schema.parse(null)).toBe("default")
     expect(schema.parse(undefined)).toBe("default")
   })
 })
 
-describe("text() custom i18n messages", () => {
+describe("text(true) custom i18n messages", () => {
   beforeEach(() => setLocale("en"))
 
   it("should use custom messages when provided", () => {
-    const schema = text({
+    const schema = text(true, {
       minLength: 5,
       i18n: {
         en: {
@@ -215,7 +215,7 @@ describe("text() custom i18n messages", () => {
   })
 
   it("should fallback to default messages when custom not provided", () => {
-    const schema = text({
+    const schema = text(true, {
       maxLength: 3,
       i18n: {
         en: {
@@ -232,7 +232,7 @@ describe("text() custom i18n messages", () => {
   })
 
   it("should use correct locale for custom messages", () => {
-    const schema = text({
+    const schema = text(true, {
       i18n: {
         en: {
           required: "English required",
@@ -251,11 +251,11 @@ describe("text() custom i18n messages", () => {
   })
 })
 
-describe("text() complex scenarios", () => {
+describe("text(true) complex scenarios", () => {
   beforeEach(() => setLocale("en")) // Ensure a consistent locale for this test
 
   it("should work with multiple validations", () => {
-    const schema = text({
+    const schema = text(true, {
       minLength: 5,
       maxLength: 20,
       startsWith: "user_",
@@ -272,8 +272,7 @@ describe("text() complex scenarios", () => {
   })
 
   it("should handle null values correctly when not required", () => {
-    const schema = text({
-      required: false,
+    const schema = text(false, {
       minLength: 5,
       includes: "test",
     })