@hy_ong/zod-kit 0.0.4 → 0.0.6

package/src/common/number.ts

@@ -1,37 +0,0 @@
-import { z, ZodNullable, ZodNumber } from "zod"
-import { t } from "../i18n"
-
-export type NumberOptions<IsRequired extends boolean = true> = {
-  required?: IsRequired
-  min?: number
-  max?: number
-  defaultValue?: IsRequired extends true ? number : number | null
-}
-
-export type NumberSchema<IsRequired extends boolean> = IsRequired extends true ? ZodNumber : ZodNullable<ZodNumber>
-
-export function number<IsRequired extends boolean = true>(options?: NumberOptions<IsRequired>): NumberSchema<IsRequired> {
-  const { required = true, min, max, defaultValue } = options ?? {}
-
-  const schema = z
-    .preprocess(
-      (val) => {
-        if (val === "" || val === undefined || val === null) return defaultValue ?? null
-        return typeof val === "string" ? Number(val) : val
-      },
-      z.union([
-        z.number({
-          error: (issue) => {
-            if (issue.code === "invalid_type") return t("common.number.integer")
-            return t("common.number.required")
-          },
-        }),
-        z.null(),
-      ])
-    )
-    .refine((val) => !required || val !== null, { message: t("common.number.required") })
-    .refine((val) => val === null || min === undefined || val >= min, { message: t("common.number.min", { min }) })
-    .refine((val) => val === null || max === undefined || val <= max, { message: t("common.number.max", { max }) })
-
-  return schema as unknown as NumberSchema<IsRequired>
-}

package/src/common/password.ts

@@ -1,33 +0,0 @@
-import { z, ZodNullable, ZodString } from "zod"
-import { t } from "../i18n"
-
-export type PasswordOptions<IsRequired extends boolean = true> = {
-  required?: IsRequired
-  min?: number
-  max?: number
-  uppercase?: boolean
-  lowercase?: boolean
-  digits?: boolean
-  special?: boolean
-}
-
-export type PasswordSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>
-
-export function password<IsRequired extends boolean = true>(options?: PasswordOptions<IsRequired>): PasswordSchema<IsRequired> {
-  const { required = true, min, max, uppercase, lowercase, digits, special } = options ?? {}
-
-  const baseSchema = required
-    ? z.preprocess((val) => (val === "" || val === null || val === undefined ? null : val), z.coerce.string().trim())
-    : z.preprocess((val) => (val === "" || val === null || val === undefined ? null : val), z.coerce.string().trim().nullable())
-
-  const schema = baseSchema
-    .refine((val) => (required ? val !== "" && val !== "null" && val !== "undefined" : true), { message: t("common.password.required") })
-    .refine((val) => val === null || min === undefined || val.length >= min, { message: t("common.password.min", { min }) })
-    .refine((val) => val === null || max === undefined || val.length <= max, { message: t("common.password.max", { max }) })
-    .refine((val) => val === null || !uppercase || /[A-Z]/.test(val), { message: t("common.password.uppercase") })
-    .refine((val) => val === null || !lowercase || /[a-z]/.test(val), { message: t("common.password.lowercase") })
-    .refine((val) => val === null || !special || /[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]+/.test(val), { message: t("common.password.special") })
-    .refine((val) => val === null || !digits || /[0-9]/.test(val), { message: t("common.password.digits") })
-
-  return schema as unknown as PasswordSchema<IsRequired>
-}

package/src/common/text.ts

@@ -1,34 +0,0 @@
-import { z, ZodNullable, ZodString } from "zod"
-import { t } from "../i18n"
-
-export type TextOptions<IsRequired extends boolean = true> = {
-  required?: IsRequired
-  min?: number
-  max?: number
-  startsWith?: string
-  endsWith?: string
-  includes?: string
-  regex?: RegExp
-  defaultValue?: IsRequired extends true ? string : string | null
-}
-
-export type TextSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>
-
-export function text<IsRequired extends boolean = true>(options?: TextOptions<IsRequired>): TextSchema<IsRequired> {
-  const { required = true, min, max, startsWith, endsWith, includes, regex, defaultValue = null } = options ?? {}
-
-  const baseSchema = required
-    ? z.preprocess((val) => (val === "" || val === null || val === undefined ? defaultValue : val), z.coerce.string().trim())
-    : z.preprocess((val) => (val === "" || val === null || val === undefined ? defaultValue : val), z.coerce.string().trim().nullable())
-
-  const schema = baseSchema
-    .refine((val) => (required ? val !== "" && val !== "null" && val !== "undefined" : true), { message: t("common.text.required") })
-    .refine((val) => val === null || min === undefined || val.length >= min, { message: t("common.text.min", { min }) })
-    .refine((val) => val === null || max === undefined || val.length <= max, { message: t("common.text.max", { max }) })
-    .refine((val) => val === null || startsWith === undefined || val.startsWith(startsWith), { message: t("common.text.startsWith", { startsWith }) })
-    .refine((val) => val === null || endsWith === undefined || val.endsWith(endsWith), { message: t("common.text.endsWith", { endsWith }) })
-    .refine((val) => val === null || includes === undefined || val.includes(includes), { message: t("common.text.includes", { includes }) })
-    .refine((val) => val === null || regex === undefined || regex.test(val), { message: t("common.text.invalid", { regex }) })
-
-  return schema as unknown as TextSchema<IsRequired>
-}

package/src/common/url.ts

@@ -1,37 +0,0 @@
-import { z, ZodNullable, ZodString } from "zod"
-import { t } from "../i18n"
-import { TextSchema } from "./text"
-
-export type UrlOptions<IsRequired extends boolean = true> = {
-  required?: IsRequired
-  min?: number
-  max?: number
-  includes?: string
-}
-
-export type UrlSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>
-
-export function url<IsRequired extends boolean = true>(options?: UrlOptions<IsRequired>): UrlSchema<IsRequired> {
-  const { required = true, min, max, includes } = options ?? {}
-
-  const baseSchema = required
-    ? z.preprocess(
-        (val) => (val === "" || val === null || val === undefined ? null : val),
-        z.url({
-          error: (issue) => {
-            if (issue.code === "invalid_type") return t("common.url.required")
-            else if (issue.code === "invalid_format") return t("common.url.invalid")
-            return t("common.url.invalid")
-          },
-        })
-      )
-    : z.preprocess((val) => (val === "" || val === null || val === undefined ? null : val), z.url({ message: t("common.url.invalid") }).nullable())
-
-  const schema = baseSchema
-    .refine((val) => (required ? val !== "" && val !== "null" && val !== "undefined" : true), { message: t("common.text.required") })
-    .refine((val) => val === null || min === undefined || val.length >= min, { message: t("common.text.min", { min }) })
-    .refine((val) => val === null || max === undefined || val.length <= max, { message: t("common.text.max", { max }) })
-    .refine((val) => val === null || includes === undefined || val.includes(includes), { message: t("common.text.includes", { includes }) })
-
-  return schema as unknown as TextSchema<IsRequired>
-}

package/tests/common/integer.test.ts

@@ -1,90 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest"
-import { setLocale, integer, Locale } from "../../src"
-
-const locales = [
-  {
-    locale: "en",
-    messages: {
-      required: "Required",
-      min: "Must be at least 3",
-      max: "Must be at most 10",
-      integer: "Must be an integer",
-    },
-  },
-  {
-    locale: "zh-TW",
-    messages: {
-      required: "必填",
-      min: "最小值 3",
-      max: "最大值 10",
-      integer: "必須為整數",
-    },
-  },
-] as const
-
-describe.each(locales)("integer() locale: $locale", ({ locale, messages }) => {
-  beforeEach(() => setLocale(locale as Locale))
-
-  it("should pass with valid integer", () => {
-    const schema = integer()
-    expect(schema.parse(42)).toBe(42)
-  })
-
-  it("should parse string number as integer", () => {
-    const schema = integer()
-    expect(schema.parse("100")).toBe(100)
-  })
-
-  it("should fail for decimal value", () => {
-    const schema = integer()
-    expect(() => schema.parse(3.14)).toThrow(messages.integer)
-  })
-
-  it("should fail for non-numeric string", () => {
-    const schema = integer()
-    expect(() => schema.parse("abc")).toThrow(messages.integer)
-    expect(() => schema.parse("10a")).toThrow(messages.integer)
-  })
-
-  it("should allow null if not required", () => {
-    const schema = integer({ required: false })
-    expect(schema.parse("")).toBe(null)
-    expect(schema.parse(null)).toBe(null)
-    expect(schema.parse(undefined)).toBe(null)
-  })
-
-  it("should fail when required and input is empty", () => {
-    const schema = integer({ required: true })
-    expect(() => schema.parse("")).toThrow(messages.required)
-    expect(() => schema.parse(null)).toThrow(messages.required)
-    expect(() => schema.parse(undefined)).toThrow(messages.required)
-  })
-
-  it("should apply default value even when required", () => {
-    const schema = integer({ required: true, defaultValue: 5 })
-    expect(schema.parse("")).toBe(5)
-    expect(schema.parse(null)).toBe(5)
-    expect(schema.parse(undefined)).toBe(5)
-  })
-
-  it("should apply default value even when required", () => {
-    const schema = integer({ required: false, defaultValue: 5 })
-    expect(schema.parse("")).toBe(5)
-    expect(schema.parse(null)).toBe(5)
-    expect(schema.parse(undefined)).toBe(5)
-  })
-
-  it("should enforce min", () => {
-    const schema = integer({ min: 3 })
-    expect(schema.parse(3)).toBe(3)
-    expect(() => schema.parse(2)).toThrow(messages.min)
-    expect(() => schema.parse("2")).toThrow(messages.min)
-  })
-
-  it("should enforce max", () => {
-    const schema = integer({ max: 10 })
-    expect(schema.parse(10)).toBe(10)
-    expect(() => schema.parse(11)).toThrow(messages.max)
-    expect(() => schema.parse("11")).toThrow(messages.max)
-  })
-})