@hy_ong/zod-kit 0.2.1 → 0.2.3

package/src/validators/common/one-of.ts

@@ -0,0 +1,172 @@
+/**
+ * @fileoverview OneOf validator for Zod Kit
+ *
+ * Provides single-select validation that restricts input to a predefined set of allowed values,
+ * with support for case-insensitive matching, default values, and transformation.
+ *
+ * @author Ong Hoe Yuan
+ * @version 0.2.2
+ */
+
+import { z, ZodType } from "zod"
+import { t } from "../../i18n"
+import { getLocale, type Locale } from "../../config"
+
+/**
+ * Type definition for oneOf validation error messages
+ *
+ * @interface OneOfMessages
+ * @property {string} [required] - Message when field is required but empty
+ * @property {string} [invalid] - Message when value is not in the allowed list
+ */
+export type OneOfMessages = {
+  required?: string
+  invalid?: string
+}
+
+/**
+ * Configuration options for oneOf validation
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ * @template T - The type of allowed values
+ *
+ * @interface OneOfOptions
+ * @property {T[]} values - Array of allowed values
+ * @property {T | null} [defaultValue] - Default value when input is empty
+ * @property {boolean} [caseSensitive=true] - Whether string matching is case-sensitive
+ * @property {Function} [transform] - Custom transformation function applied after validation
+ * @property {Record<Locale, OneOfMessages>} [i18n] - Custom error messages for different locales
+ */
+export type OneOfOptions<IsRequired extends boolean = true, T extends string | number = string | number> = {
+  values: T[]
+  defaultValue?: IsRequired extends true ? T : T | null
+  caseSensitive?: boolean
+  transform?: (value: T) => T
+  i18n?: Partial<Record<Locale, Partial<OneOfMessages>>>
+}
+
+/**
+ * Type alias for oneOf validation schema based on required flag
+ *
+ * @template IsRequired - Whether the field is required
+ * @template T - The type of allowed values
+ */
+export type OneOfSchema<IsRequired extends boolean, T> = IsRequired extends true ? ZodType<T> : ZodType<T | null>
+
+/**
+ * Creates a Zod schema for single-select validation that restricts values to a predefined set
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ * @template T - The type of allowed values (string | number)
+ * @param {IsRequired} [required=false] - Whether the field is required
+ * @param {OneOfOptions<IsRequired, T>} options - Configuration options (values is required)
+ * @returns {OneOfSchema<IsRequired, T>} Zod schema for oneOf validation
+ *
+ * @example
+ * ```typescript
+ * // Basic single-select validation (optional by default)
+ * const roleSchema = oneOf(false, { values: ["admin", "editor", "viewer"] })
+ * roleSchema.parse("admin") // ✓ "admin"
+ * roleSchema.parse(null)    // ✓ null
+ *
+ * // Required
+ * const statusSchema = oneOf(true, { values: ["active", "inactive", "pending"] })
+ * statusSchema.parse("active") // ✓ "active"
+ * statusSchema.parse(null)     // ✗ Required
+ * statusSchema.parse("banned") // ✗ Invalid
+ *
+ * // Numeric values
+ * const prioritySchema = oneOf(true, { values: [1, 2, 3, 4, 5] })
+ * prioritySchema.parse(3)  // ✓ 3
+ * prioritySchema.parse(10) // ✗ Invalid
+ *
+ * // Case-insensitive matching
+ * const colorSchema = oneOf(true, {
+ *   values: ["red", "green", "blue"],
+ *   caseSensitive: false
+ * })
+ * colorSchema.parse("RED")   // ✓ "red" (normalized to match original)
+ * colorSchema.parse("Green") // ✓ "green"
+ *
+ * // With default value
+ * const tierSchema = oneOf(false, {
+ *   values: ["free", "pro", "enterprise"],
+ *   defaultValue: "free"
+ * })
+ * tierSchema.parse(null) // ✓ "free"
+ *
+ * // With transform
+ * const sizeSchema = oneOf(true, {
+ *   values: ["s", "m", "l", "xl"],
+ *   transform: (val) => val.toUpperCase() as any
+ * })
+ * sizeSchema.parse("m") // ✓ "M"
+ * ```
+ */
+export function oneOf<IsRequired extends boolean = false, T extends string | number = string | number>(
+  required?: IsRequired,
+  options?: Omit<OneOfOptions<IsRequired, T>, "required">,
+): OneOfSchema<IsRequired, T> {
+  const { values = [] as unknown as T[], defaultValue = null, caseSensitive = true, transform, i18n } = options ?? {}
+
+  const isRequired = required ?? (false as IsRequired)
+
+  const getMessage = (key: keyof OneOfMessages, params?: Record<string, any>) => {
+    if (i18n) {
+      const currentLocale = getLocale()
+      const customMessages = i18n[currentLocale]
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key]!
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "")
+      }
+    }
+    return t(`common.oneOf.${key}`, params)
+  }
+
+  const preprocessFn = (val: unknown) => {
+    if (val === "" || val === null || val === undefined) {
+      return defaultValue
+    }
+
+    // Coerce number strings to numbers when values contains numbers
+    const hasNumbers = values.some((v) => typeof v === "number")
+    if (hasNumbers && typeof val === "string" && !isNaN(Number(val)) && val.trim() !== "") {
+      const numVal = Number(val)
+      if ((values as number[]).includes(numVal)) return numVal
+    }
+
+    // Case-insensitive normalization for string values
+    if (!caseSensitive && typeof val === "string") {
+      const match = values.find((v) => typeof v === "string" && v.toLowerCase() === val.toLowerCase())
+      if (match !== undefined) return match
+      return val
+    }
+
+    return val
+  }
+
+  const baseSchema = z.preprocess(preprocessFn, z.any())
+
+  const schema = baseSchema
+    .superRefine((val, ctx) => {
+      if (val === null) {
+        if (isRequired) {
+          ctx.addIssue({ code: "custom", message: getMessage("required") })
+        }
+        return
+      }
+
+      if (!values.includes(val as T)) {
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("invalid", { values: values.join(", ") }),
+        })
+      }
+    })
+    .transform((val) => {
+      if (val === null || !transform) return val
+      return transform(val as T)
+    })
+
+  return schema as unknown as OneOfSchema<IsRequired, T>
+}

package/tests/common/id.test.ts

@@ -11,6 +11,9 @@ const locales = [
       maxLength: "Must be at most 10 characters",
       numeric: "Must be a numeric ID",
       uuid: "Must be a valid UUID",
+      uuidv1: "Must be a valid UUID v1",
+      uuidv4: "Must be a valid UUID v4",
+      uuidv7: "Must be a valid UUID v7",
       objectId: "Must be a valid MongoDB ObjectId",
       nanoid: "Must be a valid Nano ID",
       snowflake: "Must be a valid Snowflake ID",
@@ -33,6 +36,9 @@ const locales = [
       maxLength: "長度最多 10 字元",
       numeric: "必須為數字 ID",
       uuid: "必須為有效的 UUID",
+      uuidv1: "必須為有效的 UUID v1",
+      uuidv4: "必須為有效的 UUID v4",
+      uuidv7: "必須為有效的 UUID v7",
       objectId: "必須為有效的 MongoDB ObjectId",
       nanoid: "必須為有效的 Nano ID",
       snowflake: "必須為有效的 Snowflake ID",
@@ -51,7 +57,20 @@ const locales = [
 // Valid test IDs for different formats
 const validIds = {
   numeric: ["1", "123", "999999", "0"],
-  uuid: ["550e8400-e29b-41d4-a716-446655440000", "6ba7b810-9dad-11d1-80b4-00c04fd430c8", "f47ac10b-58cc-4372-a567-0e02b2c3d479"],
+  uuid: [
+    "550e8400-e29b-41d4-a716-446655440000", // v4
+    "6ba7b810-9dad-11d1-80b4-00c04fd430c8", // v1
+    "f47ac10b-58cc-4372-a567-0e02b2c3d479", // v4
+    "01939fee-4b0b-7da3-a9e4-79fb4c267eb8", // v7
+    "320c3d4d-cc00-875b-8ec9-32d5f69181c0", // v8
+  ],
+  uuidv1: ["6ba7b810-9dad-11d1-80b4-00c04fd430c8", "f47ac10b-58cc-1372-a567-0e02b2c3d479"],
+  uuidv3: ["a3bb189e-8bf9-3888-9912-ace4e6543002"],
+  uuidv4: ["550e8400-e29b-41d4-a716-446655440000", "f47ac10b-58cc-4372-a567-0e02b2c3d479"],
+  uuidv5: ["886313e1-3b8a-5372-9b90-0c9aee199e5d"],
+  uuidv6: ["1ef21d2f-1207-6b90-8b50-a2e4100c5480"],
+  uuidv7: ["01939fee-4b0b-7da3-a9e4-79fb4c267eb8", "018fce07-42dc-7dc0-ba2c-9f7e777caee3"],
+  uuidv8: ["320c3d4d-cc00-875b-8ec9-32d5f69181c0"],
   objectId: ["507f1f77bcf86cd799439011", "507f191e810c19729de860ea", "5a9427648b0beebeb69579cc"],
   nanoid: ["V1StGXR8_Z5jdHi6B-myT", "3IBBoOd_b1YSlnKdvQ8fK", "9_xnJ2QZt8vKl3_Kj5f7N"],
   snowflake: ["1234567890123456789", "9876543210987654321", "5555555555555555555"],
@@ -65,11 +84,19 @@ const invalidIds = {
   numeric: ["abc", "12a", ""],
   uuid: [
     "550e8400-e29b-41d4-a716-44665544000", // too short
-    "550e8400-e29b-41d4-a716-44665544000g", // too long
-    "550e8400-e29b-61d4-a716-446655440000", // wrong version (6 instead of 1-5)
+    "550e8400-e29b-41d4-a716-44665544000g", // invalid character
+    "550e8400-e29b-91d4-a716-446655440000", // wrong version (9)
     "550e8400-e29b-41d4-c716-446655440000", // wrong variant (c instead of 8,9,a,b)
     "not-a-uuid-at-all",
   ],
+  uuidv4: [
+    "6ba7b810-9dad-11d1-80b4-00c04fd430c8", // v1, not v4
+    "01939fee-4b0b-7da3-a9e4-79fb4c267eb8", // v7, not v4
+  ],
+  uuidv7: [
+    "550e8400-e29b-41d4-a716-446655440000", // v4, not v7
+    "6ba7b810-9dad-11d1-80b4-00c04fd430c8", // v1, not v7
+  ],
   objectId: [
     "507f1f77bcf86cd79943901", // too short
     "507f1f77bcf86cd799439011g", // invalid character
@@ -192,6 +219,44 @@ describe.each(locales)("id(true) locale: $locale", ({ locale, messages }) => {
       })
     })
 
+    describe("UUID version-specific validation", () => {
+      it("should accept valid UUIDv4 and reject other versions", () => {
+        const schema = id(true, { type: "uuidv4" })
+        validIds.uuidv4.forEach((v) => expect(schema.parse(v)).toBe(v))
+        invalidIds.uuidv4.forEach((v) => expect(() => schema.parse(v)).toThrow(messages.uuidv4))
+      })
+
+      it("should accept valid UUIDv7 and reject other versions", () => {
+        const schema = id(true, { type: "uuidv7" })
+        validIds.uuidv7.forEach((v) => expect(schema.parse(v)).toBe(v))
+        invalidIds.uuidv7.forEach((v) => expect(() => schema.parse(v)).toThrow(messages.uuidv7))
+      })
+
+      it("should accept valid UUIDv1", () => {
+        const schema = id(true, { type: "uuidv1" })
+        validIds.uuidv1.forEach((v) => expect(schema.parse(v)).toBe(v))
+      })
+
+      it("should accept valid UUIDv6", () => {
+        const schema = id(true, { type: "uuidv6" })
+        validIds.uuidv6.forEach((v) => expect(schema.parse(v)).toBe(v))
+      })
+
+      it("should accept any version with generic uuid type", () => {
+        const schema = id(true, { type: "uuid" })
+        // All version-specific IDs should pass generic uuid validation
+        ;[...validIds.uuidv1, ...validIds.uuidv4, ...validIds.uuidv7, ...validIds.uuidv8].forEach((v) => expect(schema.parse(v)).toBe(v))
+      })
+
+      it("should work with allowedTypes for specific versions", () => {
+        const schema = id(true, { allowedTypes: ["uuidv4", "uuidv7"] })
+        validIds.uuidv4.forEach((v) => expect(schema.parse(v)).toBe(v))
+        validIds.uuidv7.forEach((v) => expect(schema.parse(v)).toBe(v))
+        // v1 should be rejected
+        expect(() => schema.parse("6ba7b810-9dad-11d1-80b4-00c04fd430c8")).toThrow()
+      })
+    })
+
     describe("ObjectId validation", () => {
       it("should accept valid ObjectIds", () => {
         const schema = id(true, { type: "objectId" })

package/tests/common/many-of.test.ts

@@ -0,0 +1,198 @@
+import { describe, it, expect, beforeEach } from "vitest"
+import { manyOf, setLocale, Locale } from "../../src"
+
+const locales = [
+  {
+    locale: "en-US",
+    messages: {
+      required: "Required",
+      invalid: "Must be from: react, vue, angular, svelte",
+      minSelect: "Must select at least 2 item(s)",
+      maxSelect: "Must select at most 3 item(s)",
+      duplicate: "Duplicate values are not allowed",
+    },
+  },
+  {
+    locale: "zh-TW",
+    messages: {
+      required: "必填",
+      invalid: "必須為以下值之一：react, vue, angular, svelte",
+      minSelect: "至少需選擇 2 項",
+      maxSelect: "最多只能選擇 3 項",
+      duplicate: "不允許重複的值",
+    },
+  },
+] as const
+
+const frameworks = ["react", "vue", "angular", "svelte"] as const
+
+describe.each(locales)("manyOf(true) locale: $locale", ({ locale, messages }) => {
+  beforeEach(() => setLocale(locale as Locale))
+
+  describe("basic functionality", () => {
+    it("should accept valid arrays", () => {
+      const schema = manyOf(true, { values: [...frameworks] })
+      expect(schema.parse(["react"])).toEqual(["react"])
+      expect(schema.parse(["react", "vue"])).toEqual(["react", "vue"])
+      expect(schema.parse(["react", "vue", "angular", "svelte"])).toEqual(["react", "vue", "angular", "svelte"])
+    })
+
+    it("should reject invalid values in array", () => {
+      const schema = manyOf(true, { values: [...frameworks] })
+      expect(() => schema.parse(["react", "jquery"])).toThrow(messages.invalid)
+    })
+
+    it("should fail with empty when required", () => {
+      const schema = manyOf(true, { values: [...frameworks] })
+      expect(() => schema.parse(null)).toThrow(messages.required)
+      expect(() => schema.parse(undefined)).toThrow(messages.required)
+      expect(() => schema.parse("")).toThrow(messages.required)
+    })
+
+    it("should pass with null when not required", () => {
+      const schema = manyOf(false, { values: [...frameworks] })
+      expect(schema.parse(null)).toBe(null)
+      expect(schema.parse(undefined)).toBe(null)
+      expect(schema.parse("")).toBe(null)
+    })
+
+    it("should wrap single value in array", () => {
+      const schema = manyOf(true, { values: [...frameworks] })
+      expect(schema.parse("react")).toEqual(["react"])
+    })
+  })
+
+  describe("min/max selection", () => {
+    it("should enforce minimum selections", () => {
+      const schema = manyOf(true, { values: [...frameworks], min: 2 })
+      expect(() => schema.parse(["react"])).toThrow(messages.minSelect)
+      expect(schema.parse(["react", "vue"])).toEqual(["react", "vue"])
+    })
+
+    it("should enforce maximum selections", () => {
+      const schema = manyOf(true, { values: [...frameworks], max: 3 })
+      expect(() => schema.parse(["react", "vue", "angular", "svelte"])).toThrow(messages.maxSelect)
+      expect(schema.parse(["react", "vue", "angular"])).toEqual(["react", "vue", "angular"])
+    })
+
+    it("should enforce both min and max", () => {
+      const schema = manyOf(true, { values: [...frameworks], min: 2, max: 3 })
+      expect(() => schema.parse(["react"])).toThrow(messages.minSelect)
+      expect(() => schema.parse(["react", "vue", "angular", "svelte"])).toThrow(messages.maxSelect)
+      expect(schema.parse(["react", "vue"])).toEqual(["react", "vue"])
+      expect(schema.parse(["react", "vue", "angular"])).toEqual(["react", "vue", "angular"])
+    })
+  })
+
+  describe("duplicate handling", () => {
+    it("should reject duplicates by default", () => {
+      const schema = manyOf(true, { values: [...frameworks] })
+      expect(() => schema.parse(["react", "react"])).toThrow(messages.duplicate)
+    })
+
+    it("should allow duplicates when configured", () => {
+      const schema = manyOf(true, { values: [...frameworks], allowDuplicates: true })
+      expect(schema.parse(["react", "react"])).toEqual(["react", "react"])
+    })
+  })
+
+  describe("numeric values", () => {
+    it("should accept valid numeric arrays", () => {
+      const schema = manyOf(true, { values: [1, 2, 3, 4, 5] })
+      expect(schema.parse([1, 3, 5])).toEqual([1, 3, 5])
+    })
+
+    it("should reject invalid numeric values", () => {
+      const schema = manyOf(true, { values: [1, 2, 3] })
+      expect(() => schema.parse([1, 10])).toThrow()
+    })
+
+    it("should coerce number strings", () => {
+      const schema = manyOf(true, { values: [1, 2, 3] })
+      expect(schema.parse(["1", "2"])).toEqual([1, 2])
+    })
+  })
+
+  describe("case sensitivity", () => {
+    it("should be case sensitive by default", () => {
+      const schema = manyOf(true, { values: [...frameworks] })
+      expect(() => schema.parse(["React"])).toThrow()
+    })
+
+    it("should match case-insensitively when configured", () => {
+      const schema = manyOf(true, { values: [...frameworks], caseSensitive: false })
+      expect(schema.parse(["REACT", "Vue"])).toEqual(["react", "vue"])
+    })
+  })
+
+  describe("default value", () => {
+    it("should use default value when input is empty", () => {
+      const schema = manyOf(false, { values: [...frameworks], defaultValue: ["react"] })
+      expect(schema.parse(null)).toEqual(["react"])
+      expect(schema.parse(undefined)).toEqual(["react"])
+      expect(schema.parse("")).toEqual(["react"])
+    })
+
+    it("should use provided value over default", () => {
+      const schema = manyOf(false, { values: [...frameworks], defaultValue: ["react"] })
+      expect(schema.parse(["vue", "angular"])).toEqual(["vue", "angular"])
+    })
+  })
+
+  describe("transform", () => {
+    it("should apply transform to valid arrays", () => {
+      const schema = manyOf(true, {
+        values: [...frameworks],
+        transform: (vals) => vals.map((v) => v.toUpperCase()) as any,
+      })
+      expect(schema.parse(["react", "vue"])).toEqual(["REACT", "VUE"])
+    })
+  })
+
+  describe("custom i18n", () => {
+    it("should use custom messages when provided", () => {
+      const schema = manyOf(true, {
+        values: [...frameworks],
+        i18n: {
+          "en-US": { required: "Pick frameworks!", duplicate: "No repeats!" },
+          "zh-TW": { required: "請選擇框架！", duplicate: "不能重複！" },
+        },
+      })
+
+      if (locale === "en-US") {
+        expect(() => schema.parse(null)).toThrow("Pick frameworks!")
+        expect(() => schema.parse(["react", "react"])).toThrow("No repeats!")
+      } else {
+        expect(() => schema.parse(null)).toThrow("請選擇框架！")
+        expect(() => schema.parse(["react", "react"])).toThrow("不能重複！")
+      }
+    })
+  })
+
+  describe("complex scenarios", () => {
+    it("should work with all options combined", () => {
+      const schema = manyOf(true, {
+        values: [...frameworks],
+        min: 1,
+        max: 3,
+        caseSensitive: false,
+      })
+
+      expect(schema.parse(["REACT", "Vue"])).toEqual(["react", "vue"])
+      expect(() => schema.parse([])).toThrow() // min 1
+      expect(() => schema.parse(["react", "vue", "angular", "svelte"])).toThrow() // max 3
+      expect(() => schema.parse(["jquery"])).toThrow() // invalid
+    })
+
+    it("should handle empty array when required with no min", () => {
+      const schema = manyOf(true, { values: [...frameworks] })
+      // Empty array is a valid array, just has 0 items — not null
+      expect(schema.parse([])).toEqual([])
+    })
+
+    it("should handle empty array with min constraint", () => {
+      const schema = manyOf(true, { values: [...frameworks], min: 1 })
+      expect(() => schema.parse([])).toThrow()
+    })
+  })
+})

package/tests/common/one-of.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect, beforeEach } from "vitest"
+import { oneOf, setLocale, Locale } from "../../src"
+
+const locales = [
+  {
+    locale: "en-US",
+    messages: {
+      required: "Required",
+      invalid: "Must be one of: admin, editor, viewer",
+    },
+  },
+  {
+    locale: "zh-TW",
+    messages: {
+      required: "必填",
+      invalid: "必須為以下其中一個值：admin, editor, viewer",
+    },
+  },
+] as const
+
+const stringValues = ["admin", "editor", "viewer"] as const
+const numericValues = [1, 2, 3, 4, 5] as const
+
+describe.each(locales)("oneOf(true) locale: $locale", ({ locale, messages }) => {
+  beforeEach(() => setLocale(locale as Locale))
+
+  describe("basic functionality", () => {
+    it("should accept valid values", () => {
+      const schema = oneOf(true, { values: [...stringValues] })
+      expect(schema.parse("admin")).toBe("admin")
+      expect(schema.parse("editor")).toBe("editor")
+      expect(schema.parse("viewer")).toBe("viewer")
+    })
+
+    it("should reject invalid values", () => {
+      const schema = oneOf(true, { values: [...stringValues] })
+      expect(() => schema.parse("hacker")).toThrow(messages.invalid)
+      expect(() => schema.parse("superadmin")).toThrow(messages.invalid)
+    })
+
+    it("should fail with empty when required", () => {
+      const schema = oneOf(true, { values: [...stringValues] })
+      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 = oneOf(false, { values: [...stringValues] })
+      expect(schema.parse("")).toBe(null)
+      expect(schema.parse(null)).toBe(null)
+      expect(schema.parse(undefined)).toBe(null)
+    })
+  })
+
+  describe("numeric values", () => {
+    it("should accept valid numeric values", () => {
+      const schema = oneOf(true, { values: [...numericValues] })
+      expect(schema.parse(1)).toBe(1)
+      expect(schema.parse(3)).toBe(3)
+      expect(schema.parse(5)).toBe(5)
+    })
+
+    it("should reject invalid numeric values", () => {
+      const schema = oneOf(true, { values: [...numericValues] })
+      expect(() => schema.parse(10)).toThrow()
+      expect(() => schema.parse(0)).toThrow()
+    })
+
+    it("should coerce number strings to numbers", () => {
+      const schema = oneOf(true, { values: [...numericValues] })
+      expect(schema.parse("3")).toBe(3)
+      expect(schema.parse("5")).toBe(5)
+    })
+  })
+
+  describe("case sensitivity", () => {
+    it("should be case sensitive by default", () => {
+      const schema = oneOf(true, { values: [...stringValues] })
+      expect(() => schema.parse("Admin")).toThrow()
+      expect(() => schema.parse("EDITOR")).toThrow()
+    })
+
+    it("should match case-insensitively when configured", () => {
+      const schema = oneOf(true, { values: [...stringValues], caseSensitive: false })
+      expect(schema.parse("Admin")).toBe("admin")
+      expect(schema.parse("EDITOR")).toBe("editor")
+      expect(schema.parse("VIEWER")).toBe("viewer")
+    })
+  })
+
+  describe("default value", () => {
+    it("should use default value when input is empty", () => {
+      const schema = oneOf(false, { values: [...stringValues], defaultValue: "viewer" })
+      expect(schema.parse("")).toBe("viewer")
+      expect(schema.parse(null)).toBe("viewer")
+      expect(schema.parse(undefined)).toBe("viewer")
+    })
+
+    it("should use provided value over default", () => {
+      const schema = oneOf(false, { values: [...stringValues], defaultValue: "viewer" })
+      expect(schema.parse("admin")).toBe("admin")
+    })
+  })
+
+  describe("transform", () => {
+    it("should apply transform to valid values", () => {
+      const schema = oneOf(true, {
+        values: [...stringValues],
+        transform: (val) => val.toUpperCase() as any,
+      })
+      expect(schema.parse("admin")).toBe("ADMIN")
+      expect(schema.parse("editor")).toBe("EDITOR")
+    })
+  })
+
+  describe("custom i18n", () => {
+    it("should use custom messages when provided", () => {
+      const schema = oneOf(true, {
+        values: [...stringValues],
+        i18n: {
+          "en-US": { required: "Pick a role!", invalid: "Bad role!" },
+          "zh-TW": { required: "請選擇角色！", invalid: "無效角色！" },
+        },
+      })
+
+      if (locale === "en-US") {
+        expect(() => schema.parse("")).toThrow("Pick a role!")
+        expect(() => schema.parse("hacker")).toThrow("Bad role!")
+      } else {
+        expect(() => schema.parse("")).toThrow("請選擇角色！")
+        expect(() => schema.parse("hacker")).toThrow("無效角色！")
+      }
+    })
+  })
+})

package/tsup.config.ts

@@ -9,7 +9,9 @@ export default defineConfig({
     "common/email": "src/validators/common/email.ts",
     "common/file": "src/validators/common/file.ts",
     "common/id": "src/validators/common/id.ts",
+    "common/many-of": "src/validators/common/many-of.ts",
     "common/number": "src/validators/common/number.ts",
+    "common/one-of": "src/validators/common/one-of.ts",
     "common/password": "src/validators/common/password.ts",
     "common/text": "src/validators/common/text.ts",
     "common/time": "src/validators/common/time.ts",