@hy_ong/zod-kit 0.2.0 → 0.2.2

package/src/validators/common/credit-card.ts

@@ -0,0 +1,134 @@
+import { z, ZodNullable, ZodString } from "zod"
+import { t } from "../../i18n"
+import { getLocale, type Locale } from "../../config"
+
+export type CreditCardType = "visa" | "mastercard" | "amex" | "jcb" | "discover" | "unionpay" | "any"
+
+export type CreditCardMessages = {
+  required?: string
+  invalid?: string
+  notInWhitelist?: string
+}
+
+export type CreditCardOptions<IsRequired extends boolean = true> = {
+  cardType?: CreditCardType | CreditCardType[]
+  whitelist?: string[]
+  transform?: (value: string) => string
+  defaultValue?: IsRequired extends true ? string : string | null
+  i18n?: Partial<Record<Locale, Partial<CreditCardMessages>>>
+}
+
+export type CreditCardSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>
+
+export function detectCardType(value: string): CreditCardType {
+  const digits = value.replace(/[\s-]/g, "")
+
+  if (/^4/.test(digits)) return "visa"
+  if (/^5[1-5]/.test(digits) || /^2[2-7]/.test(digits)) return "mastercard"
+  if (/^3[47]/.test(digits)) return "amex"
+  if (/^35/.test(digits)) return "jcb"
+  if (/^6011/.test(digits) || /^65/.test(digits) || /^64[4-9]/.test(digits)) return "discover"
+  if (/^62/.test(digits)) return "unionpay"
+
+  return "any"
+}
+
+export function validateCreditCard(value: string): boolean {
+  const digits = value.replace(/[\s-]/g, "")
+
+  if (!/^\d{13,19}$/.test(digits)) return false
+
+  let sum = 0
+  let alternate = false
+
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let n = parseInt(digits[i], 10)
+
+    if (alternate) {
+      n *= 2
+      if (n > 9) n -= 9
+    }
+
+    sum += n
+    alternate = !alternate
+  }
+
+  return sum % 10 === 0
+}
+
+export function creditCard<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<CreditCardOptions<IsRequired>, "required">): CreditCardSchema<IsRequired> {
+  const { cardType, whitelist, transform, defaultValue, i18n } = options ?? {}
+
+  const isRequired = required ?? (false as IsRequired)
+
+  const actualDefaultValue = defaultValue ?? (isRequired ? "" : null)
+
+  const getMessage = (key: keyof CreditCardMessages, 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.creditCard.${key}`, params)
+  }
+
+  const preprocessFn = (val: unknown) => {
+    if (val === "" || val === null || val === undefined) {
+      return actualDefaultValue
+    }
+
+    let processed = String(val).trim().replace(/[\s-]/g, "")
+
+    if (processed === "" && !required) {
+      return null
+    }
+
+    if (transform) {
+      processed = transform(processed)
+    }
+
+    return processed
+  }
+
+  const baseSchema = isRequired ? z.preprocess(preprocessFn, z.string()) : z.preprocess(preprocessFn, z.string().nullable())
+
+  const schema = baseSchema.superRefine((val, ctx) => {
+    if (val === null) return
+
+    if (isRequired && (val === "" || val === "null" || val === "undefined")) {
+      ctx.addIssue({ code: "custom", message: getMessage("required") })
+      return
+    }
+
+    if (!isRequired && val === "") return
+
+    if (!validateCreditCard(val)) {
+      ctx.addIssue({ code: "custom", message: getMessage("invalid") })
+      return
+    }
+
+    if (cardType) {
+      const allowedTypes = Array.isArray(cardType) ? cardType : [cardType]
+      if (!allowedTypes.includes("any")) {
+        const detected = detectCardType(val)
+        if (!allowedTypes.includes(detected)) {
+          ctx.addIssue({ code: "custom", message: getMessage("invalid") })
+          return
+        }
+      }
+    }
+
+    if (whitelist && whitelist.length > 0) {
+      const normalized = whitelist.map((w) => w.replace(/[\s-]/g, ""))
+      if (!normalized.includes(val)) {
+        ctx.addIssue({ code: "custom", message: getMessage("notInWhitelist") })
+        return
+      }
+    }
+  })
+
+  return schema as unknown as CreditCardSchema<IsRequired>
+}

package/src/validators/common/id.ts

@@ -22,6 +22,14 @@ import { getLocale, type Locale } from "../../config"
  * @property {string} [maxLength] - Message when ID is too long
  * @property {string} [numeric] - Message when numeric ID format is invalid
  * @property {string} [uuid] - Message when UUID format is invalid
+ * @property {string} [uuidv1] - Message when UUID v1 format is invalid
+ * @property {string} [uuidv2] - Message when UUID v2 format is invalid
+ * @property {string} [uuidv3] - Message when UUID v3 format is invalid
+ * @property {string} [uuidv4] - Message when UUID v4 format is invalid
+ * @property {string} [uuidv5] - Message when UUID v5 format is invalid
+ * @property {string} [uuidv6] - Message when UUID v6 format is invalid
+ * @property {string} [uuidv7] - Message when UUID v7 format is invalid
+ * @property {string} [uuidv8] - Message when UUID v8 format is invalid
  * @property {string} [objectId] - Message when MongoDB ObjectId format is invalid
  * @property {string} [nanoid] - Message when Nano ID format is invalid
  * @property {string} [snowflake] - Message when Snowflake ID format is invalid
@@ -41,6 +49,14 @@ export type IdMessages = {
   maxLength?: string
   numeric?: string
   uuid?: string
+  uuidv1?: string
+  uuidv2?: string
+  uuidv3?: string
+  uuidv4?: string
+  uuidv5?: string
+  uuidv6?: string
+  uuidv7?: string
+  uuidv8?: string
   objectId?: string
   nanoid?: string
   snowflake?: string
@@ -61,7 +77,15 @@ export type IdMessages = {
  *
  * Available types:
  * - numeric: Pure numeric IDs (1, 123, 999999)
- * - uuid: UUID v4 format (xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx)
+ * - uuid: UUID any version (v1–v8)
+ * - uuidv1: UUID v1 (timestamp-based)
+ * - uuidv2: UUID v2 (DCE security)
+ * - uuidv3: UUID v3 (MD5 name-based)
+ * - uuidv4: UUID v4 (random)
+ * - uuidv5: UUID v5 (SHA-1 name-based)
+ * - uuidv6: UUID v6 (reordered timestamp, RFC 9562)
+ * - uuidv7: UUID v7 (Unix timestamp, sortable, RFC 9562)
+ * - uuidv8: UUID v8 (custom, RFC 9562)
  * - objectId: MongoDB ObjectId (24-character hexadecimal)
  * - nanoid: Nano ID format (21-character URL-safe)
  * - snowflake: Twitter Snowflake (19-digit number)
@@ -72,7 +96,15 @@ export type IdMessages = {
  */
 export type IdType =
   | "numeric" // Pure numeric IDs (1, 123, 999999)
-  | "uuid" // UUID v4 format
+  | "uuid" // UUID any version (v1–v8)
+  | "uuidv1" // UUID v1 (timestamp-based)
+  | "uuidv2" // UUID v2 (DCE security)
+  | "uuidv3" // UUID v3 (MD5 name-based)
+  | "uuidv4" // UUID v4 (random)
+  | "uuidv5" // UUID v5 (SHA-1 name-based)
+  | "uuidv6" // UUID v6 (reordered timestamp, RFC 9562)
+  | "uuidv7" // UUID v7 (Unix timestamp, sortable, RFC 9562)
+  | "uuidv8" // UUID v8 (custom, RFC 9562)
   | "objectId" // MongoDB ObjectId (24-character hexadecimal)
   | "nanoid" // Nano ID
   | "snowflake" // Twitter Snowflake (19-digit number)
@@ -143,9 +175,19 @@ export type IdSchema<IsRequired extends boolean, Type extends IdType | undefined
  * @constant {Record<string, RegExp>} ID_PATTERNS
  * @description Maps each ID type to its corresponding regex pattern
  */
+const UUID_BASE = (version: string) => new RegExp(`^[0-9a-f]{8}-[0-9a-f]{4}-${version}[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$`, "i")
+
 const ID_PATTERNS = {
   numeric: /^\d+$/,
-  uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+  uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+  uuidv1: UUID_BASE("1"),
+  uuidv2: UUID_BASE("2"),
+  uuidv3: UUID_BASE("3"),
+  uuidv4: UUID_BASE("4"),
+  uuidv5: UUID_BASE("5"),
+  uuidv6: UUID_BASE("6"),
+  uuidv7: UUID_BASE("7"),
+  uuidv8: UUID_BASE("8"),
   objectId: /^[0-9a-f]{24}$/i,
   nanoid: /^[A-Za-z0-9_-]{21}$/,
   snowflake: /^\d{19}$/,

package/src/validators/common/ip.ts

@@ -0,0 +1,210 @@
+import { z, ZodNullable, ZodString } from "zod"
+import { t } from "../../i18n"
+import { getLocale, type Locale } from "../../config"
+
+export type IpVersion = "v4" | "v6" | "any"
+
+export type IpMessages = {
+  required?: string
+  invalid?: string
+  notIPv4?: string
+  notIPv6?: string
+  notInWhitelist?: string
+}
+
+export type IpOptions<IsRequired extends boolean = true> = {
+  version?: IpVersion
+  allowCIDR?: boolean
+  whitelist?: string[]
+  transform?: (value: string) => string
+  defaultValue?: IsRequired extends true ? string : string | null
+  i18n?: Partial<Record<Locale, Partial<IpMessages>>>
+}
+
+export type IpSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>
+
+export function validateIPv4(value: string): boolean {
+  const parts = value.split(".")
+  if (parts.length !== 4) return false
+
+  for (const part of parts) {
+    if (part === "") return false
+    // No leading zeros except for the single digit "0"
+    if (part.length > 1 && part.startsWith("0")) return false
+    const num = Number(part)
+    if (!Number.isInteger(num) || num < 0 || num > 255) return false
+  }
+
+  return true
+}
+
+export function validateIPv6(value: string): boolean {
+  // Handle mixed IPv6/IPv4 (e.g., ::ffff:192.0.2.1)
+  const lastColon = value.lastIndexOf(":")
+  if (lastColon !== -1) {
+    const afterLastColon = value.substring(lastColon + 1)
+    if (afterLastColon.includes(".")) {
+      // Mixed form: validate the IPv4 portion
+      if (!validateIPv4(afterLastColon)) return false
+
+      // Validate the IPv6 prefix portion (everything before the IPv4 part)
+      const ipv6Prefix = value.substring(0, lastColon)
+      // The prefix should behave like an IPv6 with fewer groups (max 6 groups since IPv4 occupies 2)
+      return validateIPv6Groups(ipv6Prefix, 6)
+    }
+  }
+
+  return validateIPv6Groups(value, 8)
+}
+
+function validateIPv6Groups(value: string, maxGroups: number): boolean {
+  // Handle :: compression
+  if (value.includes("::")) {
+    // Only one :: is allowed
+    const doubleColonCount = value.split("::").length - 1
+    if (doubleColonCount > 1) return false
+
+    const [left, right] = value.split("::")
+    const leftGroups = left === "" ? [] : left.split(":")
+    const rightGroups = right === "" ? [] : right.split(":")
+
+    // Total groups when expanded must not exceed maxGroups
+    if (leftGroups.length + rightGroups.length >= maxGroups) return false
+
+    // Validate each group
+    for (const group of [...leftGroups, ...rightGroups]) {
+      if (!isValidHexGroup(group)) return false
+    }
+
+    return true
+  }
+
+  // Full form: must have exactly maxGroups groups
+  const groups = value.split(":")
+  if (groups.length !== maxGroups) return false
+
+  for (const group of groups) {
+    if (!isValidHexGroup(group)) return false
+  }
+
+  return true
+}
+
+function isValidHexGroup(group: string): boolean {
+  if (group.length === 0 || group.length > 4) return false
+  return /^[0-9a-fA-F]{1,4}$/.test(group)
+}
+
+export function ip<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<IpOptions<IsRequired>, "required">): IpSchema<IsRequired> {
+  const { version = "any", allowCIDR = false, whitelist, transform, defaultValue, i18n } = options ?? {}
+
+  const isRequired = required ?? (false as IsRequired)
+
+  const actualDefaultValue = defaultValue ?? (isRequired ? "" : null)
+
+  const getMessage = (key: keyof IpMessages, 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.ip.${key}`, params)
+  }
+
+  const preprocessFn = (val: unknown) => {
+    if (val === "" || val === null || val === undefined) {
+      return actualDefaultValue
+    }
+
+    let processed = String(val).trim()
+
+    if (processed === "" && !required) {
+      return null
+    }
+
+    if (transform) {
+      processed = transform(processed)
+    }
+
+    return processed
+  }
+
+  const baseSchema = isRequired ? z.preprocess(preprocessFn, z.string()) : z.preprocess(preprocessFn, z.string().nullable())
+
+  const schema = baseSchema.superRefine((val, ctx) => {
+    if (val === null) return
+
+    // Required check
+    if (isRequired && (val === "" || val === "null" || val === "undefined")) {
+      ctx.addIssue({ code: "custom", message: getMessage("required") })
+      return
+    }
+
+    if (!isRequired && val === "") return
+
+    // Separate CIDR prefix if present
+    let ipPart = val
+    let cidrPrefix: string | null = null
+
+    const slashIndex = val.indexOf("/")
+    if (slashIndex !== -1) {
+      if (!allowCIDR) {
+        ctx.addIssue({ code: "custom", message: getMessage("invalid") })
+        return
+      }
+      ipPart = val.substring(0, slashIndex)
+      cidrPrefix = val.substring(slashIndex + 1)
+    }
+
+    // Determine which version(s) to try
+    const isV4 = validateIPv4(ipPart)
+    const isV6 = validateIPv6(ipPart)
+
+    if (version === "v4") {
+      if (!isV4) {
+        ctx.addIssue({ code: "custom", message: getMessage("notIPv4") })
+        return
+      }
+    } else if (version === "v6") {
+      if (!isV6) {
+        ctx.addIssue({ code: "custom", message: getMessage("notIPv6") })
+        return
+      }
+    } else {
+      // version === "any"
+      if (!isV4 && !isV6) {
+        ctx.addIssue({ code: "custom", message: getMessage("invalid") })
+        return
+      }
+    }
+
+    // Validate CIDR prefix length
+    if (cidrPrefix !== null) {
+      if (!/^\d+$/.test(cidrPrefix)) {
+        ctx.addIssue({ code: "custom", message: getMessage("invalid") })
+        return
+      }
+
+      const prefixNum = Number(cidrPrefix)
+      const maxPrefix = isV4 ? 32 : 128
+
+      if (prefixNum < 0 || prefixNum > maxPrefix) {
+        ctx.addIssue({ code: "custom", message: getMessage("invalid") })
+        return
+      }
+    }
+
+    // Whitelist check
+    if (whitelist && whitelist.length > 0) {
+      if (!whitelist.includes(val)) {
+        ctx.addIssue({ code: "custom", message: getMessage("notInWhitelist") })
+        return
+      }
+    }
+  })
+
+  return schema as unknown as IpSchema<IsRequired>
+}

package/src/validators/taiwan/bank-account.ts

@@ -0,0 +1,176 @@
+import { z, ZodNullable, ZodString } from "zod"
+import { t } from "../../i18n"
+import { getLocale, type Locale } from "../../config"
+
+export const TAIWAN_BANK_CODES: Record<string, string> = {
+  "004": "台灣銀行",
+  "005": "土地銀行",
+  "006": "合庫",
+  "007": "第一銀行",
+  "008": "華南",
+  "009": "彰化",
+  "011": "上海",
+  "012": "台北富邦",
+  "013": "國泰世華",
+  "017": "兆豐",
+  "021": "花旗",
+  "048": "王道",
+  "050": "台灣企銀",
+  "052": "渣打",
+  "053": "台中銀行",
+  "054": "京城",
+  "081": "滙豐",
+  "103": "新光",
+  "108": "陽信",
+  "118": "板信",
+  "147": "三信",
+  "700": "中華郵政",
+  "803": "聯邦",
+  "805": "遠東",
+  "806": "元大",
+  "807": "永豐",
+  "808": "玉山",
+  "809": "凱基",
+  "810": "星展",
+  "812": "台新",
+  "816": "安泰",
+  "822": "中信",
+}
+
+export type TwBankAccountMessages = {
+  required?: string
+  invalid?: string
+  invalidBankCode?: string
+  invalidAccountNumber?: string
+}
+
+export type TwBankAccountOptions<IsRequired extends boolean = true> = {
+  validateBankCode?: boolean
+  bankCode?: string
+  transform?: (value: string) => string
+  defaultValue?: IsRequired extends true ? string : string | null
+  i18n?: Partial<Record<Locale, Partial<TwBankAccountMessages>>>
+}
+
+export type TwBankAccountSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>
+
+const validateTaiwanBankAccount = (value: string, validateBankCode: boolean = true): boolean => {
+  let bankCode: string | undefined
+  let accountNumber: string
+
+  if (value.includes("-")) {
+    const parts = value.split("-")
+    if (parts.length !== 2) return false
+    bankCode = parts[0]
+    accountNumber = parts[1]
+  } else {
+    accountNumber = value
+  }
+
+  // Validate bank code if present
+  if (bankCode !== undefined) {
+    if (!/^\d{3}$/.test(bankCode)) return false
+    if (validateBankCode && !(bankCode in TAIWAN_BANK_CODES)) return false
+  }
+
+  // Validate account number: 10-16 digits
+  if (!/^\d{10,16}$/.test(accountNumber)) return false
+
+  return true
+}
+
+export function twBankAccount<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<TwBankAccountOptions<IsRequired>, "required">): TwBankAccountSchema<IsRequired> {
+  const { validateBankCode = true, bankCode, transform, defaultValue, i18n } = options ?? {}
+
+  const isRequired = required ?? (false as IsRequired)
+
+  const actualDefaultValue = defaultValue ?? (isRequired ? "" : null)
+
+  const getMessage = (key: keyof TwBankAccountMessages, 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(`taiwan.bankAccount.${key}`, params)
+  }
+
+  const preprocessFn = (val: unknown) => {
+    if (val === "" || val === null || val === undefined) {
+      return actualDefaultValue
+    }
+
+    let processed = String(val).trim().replace(/\s/g, "")
+
+    if (processed === "" && !required) {
+      return null
+    }
+
+    if (transform) {
+      processed = transform(processed)
+    }
+
+    // If a bankCode option is set and the value has no hyphen, prepend bankCode
+    if (bankCode && !processed.includes("-")) {
+      processed = `${bankCode}-${processed}`
+    }
+
+    return processed
+  }
+
+  const baseSchema = isRequired ? z.preprocess(preprocessFn, z.string()) : z.preprocess(preprocessFn, z.string().nullable())
+
+  const schema = baseSchema.superRefine((val, ctx) => {
+    if (val === null) return
+
+    // Required check
+    if (isRequired && (val === "" || val === "null" || val === "undefined")) {
+      ctx.addIssue({ code: "custom", message: getMessage("required") })
+      return
+    }
+
+    if (val === null) return
+    if (!isRequired && val === "") return
+
+    // Parse and validate parts separately for specific error messages
+    let parsedBankCode: string | undefined
+    let accountNumber: string
+
+    if (val.includes("-")) {
+      const parts = val.split("-")
+      if (parts.length !== 2) {
+        ctx.addIssue({ code: "custom", message: getMessage("invalid") })
+        return
+      }
+      parsedBankCode = parts[0]
+      accountNumber = parts[1]
+    } else {
+      accountNumber = val
+    }
+
+    // Validate bank code if present
+    if (parsedBankCode !== undefined) {
+      if (!/^\d{3}$/.test(parsedBankCode)) {
+        ctx.addIssue({ code: "custom", message: getMessage("invalidBankCode") })
+        return
+      }
+      if (validateBankCode && !(parsedBankCode in TAIWAN_BANK_CODES)) {
+        ctx.addIssue({ code: "custom", message: getMessage("invalidBankCode") })
+        return
+      }
+    }
+
+    // Validate account number: 10-16 digits
+    if (!/^\d{10,16}$/.test(accountNumber)) {
+      ctx.addIssue({ code: "custom", message: getMessage("invalidAccountNumber") })
+      return
+    }
+  })
+
+  return schema as unknown as TwBankAccountSchema<IsRequired>
+}
+
+export { validateTaiwanBankAccount }

package/src/validators/taiwan/invoice.ts

@@ -0,0 +1,84 @@
+import { z, ZodNullable, ZodString } from "zod"
+import { t } from "../../i18n"
+import { getLocale, type Locale } from "../../config"
+
+export type TwInvoiceMessages = {
+  required?: string
+  invalid?: string
+}
+
+export type TwInvoiceOptions<IsRequired extends boolean = true> = {
+  transform?: (value: string) => string
+  defaultValue?: IsRequired extends true ? string : string | null
+  i18n?: Partial<Record<Locale, Partial<TwInvoiceMessages>>>
+}
+
+export type TwInvoiceSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>
+
+const INVOICE_PATTERN = /^[A-Z]{2}\d{8}$/
+
+const validateTaiwanInvoice = (value: string): boolean => {
+  const cleaned = value.replace(/-/g, "")
+  return INVOICE_PATTERN.test(cleaned)
+}
+
+export function twInvoice<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<TwInvoiceOptions<IsRequired>, "required">): TwInvoiceSchema<IsRequired> {
+  const { transform, defaultValue, i18n } = options ?? {}
+
+  const isRequired = required ?? (false as IsRequired)
+
+  const actualDefaultValue = defaultValue ?? (isRequired ? "" : null)
+
+  const getMessage = (key: keyof TwInvoiceMessages, 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(`taiwan.invoice.${key}`, params)
+  }
+
+  const preprocessFn = (val: unknown) => {
+    if (val === "" || val === null || val === undefined) {
+      return actualDefaultValue
+    }
+
+    let processed = String(val).trim().toUpperCase().replace(/-/g, "")
+
+    if (processed === "" && !required) {
+      return null
+    }
+
+    if (transform) {
+      processed = transform(processed)
+    }
+
+    return processed
+  }
+
+  const baseSchema = isRequired ? z.preprocess(preprocessFn, z.string()) : z.preprocess(preprocessFn, z.string().nullable())
+
+  const schema = baseSchema.superRefine((val, ctx) => {
+    if (val === null) return
+
+    if (isRequired && (val === "" || val === "null" || val === "undefined")) {
+      ctx.addIssue({ code: "custom", message: getMessage("required") })
+      return
+    }
+
+    if (val === null) return
+    if (!isRequired && val === "") return
+
+    if (!validateTaiwanInvoice(val)) {
+      ctx.addIssue({ code: "custom", message: getMessage("invalid") })
+      return
+    }
+  })
+
+  return schema as unknown as TwInvoiceSchema<IsRequired>
+}
+
+export { validateTaiwanInvoice }