acai-ui 1.65.5

package/src/utils/form-rules.ts

@@ -0,0 +1,202 @@
+import { horaValida, parseDataIndian } from './date-utils'
+
+const FormRules = {
+  campoObrigatorio(value: unknown): boolean | string {
+    if (value === null || value === undefined || value === '') return 'Esse campo é obrigatório'
+    if (Array.isArray(value) && value.length === 0) return 'Esse campo é obrigatório'
+    return true
+  },
+
+  /**
+   * Valida formato de e-mail.
+   * Se `dominios` for informado, aceita apenas esses domínios.
+   * @example
+   * FormRules.validarEmail()('teste@gmail.com') // true
+   * FormRules.validarEmail(['detran.pa.gov.br'])('teste@gmail.com') // 'E-mail deve ser de: detran.pa.gov.br'
+   */
+  validarEmail(dominios?: string[]) {
+    return (value: unknown): boolean | string => {
+      if (!value || typeof value !== 'string') return true
+
+      const regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/
+      if (!regex.test(value)) return 'E-mail inválido'
+
+      if (dominios && dominios.length > 0) {
+        const dominio = value.split('@')[1]?.toLowerCase()
+        const permitidos = dominios.map(d => d.toLowerCase())
+        if (!dominio || !permitidos.includes(dominio)) {
+          return `E-mail deve ser de: ${permitidos.join(', ')}`
+        }
+      }
+
+      return true
+    }
+  },
+
+  /**
+   * Valida se a data é válida (existe no calendário).
+   * Aceita formatos: dd/mm/yyyy, yyyy-mm-dd
+   * @example
+   * FormRules.validarDataValida()('31/02/2026') // 'Data inválida'
+   * FormRules.validarDataValida()('28/02/2026') // true
+   */
+  validarDataValida() {
+    return (value: unknown): boolean | string => {
+      if (!value || typeof value !== 'string') return true
+
+      // Normaliza ISO (yyyy-mm-dd) para dd/mm/yyyy e delega ao parser estrito,
+      // que é o mesmo usado pelos componentes de data — uma fonte de verdade só.
+      const iso = /^(\d{4})-(\d{2})-(\d{2})/.exec(value.trim())
+      const indian = iso ? `${iso[3]}/${iso[2]}/${iso[1]}` : value
+
+      return parseDataIndian(indian) ? true : 'Data inválida'
+    }
+  },
+
+  /**
+   * Valida hora no formato HH:mm (24h).
+   * @example
+   * FormRules.validarHoraValida()('88:77') // 'Hora inválida'
+   * FormRules.validarHoraValida()('23:59') // true
+   */
+  validarHoraValida() {
+    return (value: unknown): boolean | string => {
+      if (!value || typeof value !== 'string') return true
+      return horaValida(value) ? true : 'Hora inválida'
+    }
+  },
+
+  /**
+   * Valida data e hora juntas, no formato `dd/mm/yyyy HH:mm`.
+   * Reporta separadamente qual das duas partes está errada.
+   * @example
+   * FormRules.validarDataHoraValida()('31/02/2026 10:00') // 'Data inválida'
+   * FormRules.validarDataHoraValida()('28/02/2026 99:99') // 'Hora inválida'
+   * FormRules.validarDataHoraValida()('28/02/2026 10:00') // true
+   */
+  validarDataHoraValida() {
+    return (value: unknown): boolean | string => {
+      if (!value || typeof value !== 'string') return true
+
+      const [dataParte = '', horaParte = ''] = value.trim().split(' ')
+      if (!parseDataIndian(dataParte)) return 'Data inválida'
+      // Hora é opcional aqui: o usuário digita a data antes de chegar na hora e
+      // não deve levar erro de hora enquanto o campo ainda está pela metade.
+      if (horaParte && !horaValida(horaParte)) return 'Hora inválida'
+
+      return true
+    }
+  },
+
+  /**
+   * Valida se a pessoa tem idade mínima.
+   * @param idadeMinima — idade mínima em anos
+   * @example
+   * FormRules.validarIdadeMinima(18)('01/01/2010') // 'Idade mínima: 18 anos'
+   * FormRules.validarIdadeMinima(18)('01/01/2000') // true
+   */
+  validarIdadeMinima(idadeMinima: number) {
+    return (value: unknown): boolean | string => {
+      if (!value || typeof value !== 'string') return true
+
+      const iso = /^(\d{4})-(\d{2})-(\d{2})/.exec(value.trim())
+      const indian = iso ? `${iso[3]}/${iso[2]}/${iso[1]}` : value
+
+      // Mesmo parser estrito: antes 31/02/2010 virava 03/03/2010 e a idade era
+      // calculada em cima de uma data que não existe.
+      const nascimento = parseDataIndian(indian)
+      if (!nascimento) return 'Data inválida'
+
+      const hoje = new Date()
+      let idade = hoje.getFullYear() - nascimento.getFullYear()
+      const mesAtual = hoje.getMonth() - nascimento.getMonth()
+
+      if (mesAtual < 0 || (mesAtual === 0 && hoje.getDate() < nascimento.getDate())) {
+        idade--
+      }
+
+      if (idade < idadeMinima) return `Idade mínima: ${idadeMinima} anos`
+
+      return true
+    }
+  },
+
+  /**
+   * Valida placa de veículo brasileira.
+   * Aceita formato antigo (ABC-1234) e Mercosul (ABC1D23).
+   * @example
+   * FormRules.validarPlaca()('ABC1D23') // true
+   * FormRules.validarPlaca()('ABC-1234') // true
+   * FormRules.validarPlaca()('123-ABCD') // 'Placa inválida'
+   */
+  validarPlaca() {
+    return (value: unknown): boolean | string => {
+      if (!value || typeof value !== 'string') return true
+
+      const limpo = value.replace(/[-\s]/g, '').toUpperCase()
+
+      // Formato antigo: ABC1234
+      const antigo = /^[A-Z]{3}\d{4}$/
+      // Formato Mercosul: ABC1D23
+      const mercosul = /^[A-Z]{3}\d[A-Z]\d{2}$/
+
+      if (!antigo.test(limpo) && !mercosul.test(limpo)) return 'Placa inválida'
+
+      return true
+    }
+  },
+
+  /**
+   * Valida CPF com dígito verificador. Usável direto em `:rules`.
+   * Vazio retorna `true` (deixe `campoObrigatorio` cuidar do obrigatório).
+   * @example FormRules.validarCpf('111.444.777-35') // true
+   */
+  validarCpf(cpf: unknown): boolean | string {
+    if (!cpf || typeof cpf !== 'string') return true
+    const cpfLimpo = cpf.replace(/\D/g, '')
+
+    if (cpfLimpo.length !== 11) return 'Informe um CPF válido'
+    if (/^(\d)\1+$/.test(cpfLimpo)) return 'Informe um CPF válido'
+
+    let soma = 0
+    for (let i = 0; i < 9; i++) soma += Number(cpfLimpo.charAt(i)) * (10 - i)
+    let resto = (soma * 10) % 11
+    if (resto === 10) resto = 0
+    if (resto !== Number(cpfLimpo.charAt(9))) return 'Informe um CPF válido'
+
+    soma = 0
+    for (let i = 0; i < 10; i++) soma += Number(cpfLimpo.charAt(i)) * (11 - i)
+    resto = (soma * 10) % 11
+    if (resto === 10) resto = 0
+    if (resto !== Number(cpfLimpo.charAt(10))) return 'Informe um CPF válido'
+
+    return true
+  },
+
+  /**
+   * Valida CNPJ (estrutural): 14 caracteres alfanuméricos (CNPJ alfanumérico
+   * 2026), não todos iguais. NÃO valida dígito verificador. Usável em `:rules`.
+   * Vazio retorna `true`.
+   */
+  validarCnpj(cnpj: unknown): boolean | string {
+    if (!cnpj || typeof cnpj !== 'string') return true
+    const cnpjLimpo = cnpj.replace(/[^A-Za-z0-9]/g, '').toUpperCase()
+
+    if (cnpjLimpo.length !== 14) return 'Informe um CNPJ válido'
+    if (!/^[A-Z0-9]+$/.test(cnpjLimpo)) return 'Informe um CNPJ válido'
+    if (/^([A-Z0-9])\1+$/.test(cnpjLimpo)) return 'Informe um CNPJ válido'
+
+    return true
+  },
+}
+
+export default FormRules
+
+/**
+ * Dispara a validação de um form/campo do Quasar e resolve o resultado.
+ * Aceita qualquer ref com `validate(): Promise<boolean>` (ex: QForm, AcaiUiForm).
+ * @example if (await validateForm(formRef.value)) submeter()
+ */
+export function validateForm(ref: { validate: () => Promise<boolean> }): Promise<boolean> {
+  return ref.validate()
+}

package/src/utils/formatadores.ts

@@ -0,0 +1,97 @@
+export function formatarDocumento(documento: string): string {
+  if (documento == null) return ''
+  const doc = String(documento)
+
+  // CPF: 11 dígitos
+  const digitos = doc.replace(/\D/g, '')
+  if (digitos.length === 11) {
+    return digitos.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, '$1.$2.$3-$4')
+  }
+
+  // CNPJ: 14 caracteres alfanuméricos (CNPJ alfanumérico — regra 2026).
+  // Não usar `\D` aqui senão apaga as letras do novo formato.
+  const alfanumerico = doc.replace(/[^A-Za-z0-9]/g, '')
+  if (alfanumerico.length === 14) {
+    return alfanumerico.replace(
+      /([A-Za-z0-9]{2})([A-Za-z0-9]{3})([A-Za-z0-9]{3})([A-Za-z0-9]{4})([A-Za-z0-9]{2})/,
+      '$1.$2.$3/$4-$5',
+    )
+  }
+
+  return doc
+}
+
+export function formatarCep(cep: unknown): string {
+  const digitos = (cep == null ? '' : String(cep)).replace(/\D/g, '')
+  if (digitos.length !== 8) return digitos
+  return `${digitos.slice(0, 5)}-${digitos.slice(5)}`
+}
+
+export function formatarPlacaBR(input: string): string {
+  if (!input) return ''
+  const s = input.normalize('NFD').replace(/\p{Diacritic}/gu, '').toUpperCase().replace(/[^A-Z0-9]/g, '')
+  if (s.length !== 7) return s
+  const antiga = /^([A-Z]{3})(\d{4})$/.exec(s)
+  if (antiga) return `${antiga[1]}-${antiga[2]}`
+  return s
+}
+
+export function formatarTelefone(telefone: unknown): string {
+  const bruto = telefone == null ? '' : String(telefone)
+  const digitos = bruto.replace(/\D/g, '')
+  if (digitos.length === 0) return ''
+  const local = digitos.startsWith('55') && digitos.length > 11 ? digitos.slice(2) : digitos
+  if (local.length === 11) return local.replace(/(\d{2})(\d)(\d{4})(\d{4})/, '($1) $2$3-$4')
+  if (local.length === 10) return local.replace(/(\d{2})(\d{4})(\d{4})/, '($1) $2-$3')
+  return bruto
+}
+
+export function formatarData(valor: unknown): string {
+  const bruto = valor == null ? '' : String(valor).trim()
+  if (bruto === '') return ''
+
+  const brMatch = bruto.match(/^(\d{2})\/(\d{2})\/(\d{4})/)
+  if (brMatch) return `${brMatch[1]}/${brMatch[2]}/${brMatch[3]}`
+
+  const isoMatch = bruto.match(/^(\d{4})-(\d{2})-(\d{2})/)
+  if (isoMatch) return `${isoMatch[3]}/${isoMatch[2]}/${isoMatch[1]}`
+
+  return bruto
+}
+
+export function formatarValorBR(valor: number | string): string {
+  const numero = typeof valor === 'string' ? Number(valor.replace(/\./g, '').replace(',', '.')) : valor
+  if (Number.isNaN(numero)) return ''
+  return numero.toLocaleString('pt-BR', { style: 'currency', currency: 'BRL' })
+}
+
+export function truncarTexto(texto: string, limite: number): string {
+  if (texto.length <= limite) return texto
+  return texto.slice(0, limite) + '...'
+}
+
+export function temValor(v: unknown): boolean {
+  if (v === null || v === undefined) return false
+  if (typeof v === 'string') return v.trim() !== ''
+  if (typeof v === 'number' && Number.isNaN(v)) return false
+  return true
+}
+
+/** Remove tudo que não for dígito de um valor com máscara: `'(91) 99999-9999'` → `'91999999999'`. */
+export function limparMascara(valor: string | null | undefined): string {
+  return valor ? valor.replace(/\D/g, '') : ''
+}
+
+/** Converte valor em string, com fallback `'N/A'` para null/undefined. */
+export function transformarEmString(valor: string | number | null | undefined): string {
+  return (valor ?? 'N/A').toString()
+}
+
+/** CSV → array de strings (trim + remove vazios): `'a, b ,,c'` → `['a','b','c']`. */
+export function csvParaArrayDeStrings(valor: string | null | undefined): string[] {
+  if (!valor) return []
+  return valor
+    .split(',')
+    .map((v) => v.trim())
+    .filter((v) => v.length > 0)
+}

package/src/utils/gerador-id.ts

@@ -0,0 +1,29 @@
+const generatedIds: Set<string> = new Set()
+
+export function gerarId(label: string, tipo: string): string {
+  if (!label) return `default-${tipo}`
+
+  const baseId = label
+    .toLowerCase()
+    .trim()
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/\s+/g, '-')
+    .replace(/[^a-z0-9-]/g, '')
+
+  let uniqueId = `${baseId}-${tipo}`
+  let counter = 0
+
+  while (generatedIds.has(uniqueId)) {
+    counter += 1
+    uniqueId = `${baseId}-${counter}-${tipo}`
+  }
+
+  generatedIds.add(uniqueId)
+
+  return uniqueId
+}
+
+export function resetGeneratedIds(): void {
+  generatedIds.clear()
+}

package/src/utils/hint-mensagem.ts

@@ -0,0 +1,25 @@
+const Hints = {
+  pressionarXParaRegistrar(key: string) {
+    return `Pressione "${key}" para adicionar`
+  },
+  selecioneParaLiberar(key: string) {
+    return `Selecione o campo "${key}" para habilitar`
+  },
+  pressionarEnterParaPesquisar() {
+    return 'Pressione "enter" para adicionar'
+  },
+  maximoCaracter(max: string | number) {
+    return `Máximo ${max} caracteres`
+  },
+  minimoCaracter(min?: string) {
+    return `Mínimo ${min} caracteres`
+  },
+  justificativa() {
+    return 'Informe sua justificativa.'
+  },
+  campoObrigatorio() {
+    return 'Campo obrigatório'
+  },
+}
+
+export default Hints

package/src/utils/index.ts

@@ -0,0 +1,32 @@
+export { default as Masks } from './masks'
+export { default as FormRules, validateForm } from './form-rules'
+export {
+  formatarDocumento,
+  formatarCep,
+  formatarPlacaBR,
+  formatarTelefone,
+  formatarData,
+  formatarValorBR,
+  truncarTexto,
+  temValor,
+  limparMascara,
+  transformarEmString,
+  csvParaArrayDeStrings,
+} from './formatadores'
+export * from './date-utils'
+export * from './filtro-input'
+export { default as Hints } from './hint-mensagem'
+export * from './limpar-campos'
+export * from './file-utils'
+export * from './dialog-utils'
+export * from './gerador-id'
+export { obterTamanho } from './medidas-util'
+export * from './normalizar-label'
+export {
+  estaVazio,
+  temTexto,
+  temIdValido,
+  ehArquivo,
+  ehObjeto,
+} from './validar-campo'
+export * from './validar-documentos'

package/src/utils/limpar-campos.ts

@@ -0,0 +1,94 @@
+// --- limparCamposVazios ---
+// Remove chaves com valor null, undefined ou '' (recursivo em arrays e objetos)
+
+export function limparCamposVazios<T extends object>(obj: T): T {
+  const novoObj = {} as T
+  const chaves = Object.keys(obj) as (keyof T)[]
+
+  for (const key of chaves) {
+    const value = obj[key]
+
+    if (value === undefined || value === null || value === '') continue
+
+    if (Array.isArray(value)) {
+      const arrayLimpo = value
+        .map((item) => {
+          if (item !== null && typeof item === 'object') {
+            return limparCamposVazios(item as object)
+          }
+          return item
+        })
+        .filter((item) => item !== '' && item !== null && item !== undefined)
+
+      if (arrayLimpo.length > 0) {
+        novoObj[key] = arrayLimpo as (typeof novoObj)[typeof key]
+      }
+      continue
+    }
+
+    if (typeof value === 'object') {
+      const nestedObj = limparCamposVazios(value as object)
+      if (Object.keys(nestedObj as object).length > 0) {
+        novoObj[key] = nestedObj as (typeof novoObj)[typeof key]
+      }
+      continue
+    }
+
+    novoObj[key] = value
+  }
+
+  return novoObj
+}
+
+// --- limparModelo ---
+// Reseta um modelo tipado para valores padrão mantendo a estrutura
+
+type TipoConstrutorDeArquivo = new (...args: never[]) => File
+
+const ehArquivo = (v: unknown): v is File => {
+  const possuiFile = typeof globalThis !== 'undefined' && 'File' in globalThis
+  if (possuiFile) {
+    const ConstrutorArquivo = (globalThis as unknown as { File: TipoConstrutorDeArquivo }).File
+    return v instanceof ConstrutorArquivo
+  }
+  return typeof v === 'object' && v !== null && Object.prototype.toString.call(v) === '[object File]'
+}
+
+export type LimpezaProfunda<T> = T extends number
+  ? null
+  : T extends File
+    ? File | null
+    : T extends Array<infer U>
+      ? LimpezaProfunda<U>[]
+      : T extends Date
+        ? Date
+        : T extends object
+          ? { [K in keyof T]: LimpezaProfunda<T[K]> }
+          : T
+
+export function limparModelo<T extends Record<string, unknown>>(objeto: T): LimpezaProfunda<T> {
+  const limparValor = (valor: unknown): unknown => {
+    if (valor === null || valor === undefined) return valor
+    if (ehArquivo(valor)) return null
+    if (typeof valor === 'string') return ''
+    if (typeof valor === 'number') return null
+    if (typeof valor === 'boolean') return false
+    if (Array.isArray(valor)) return []
+    if (valor instanceof Date) return new Date(0)
+    if (typeof valor === 'object') {
+      const origem = valor as Record<string, unknown>
+      const destino: Record<string, unknown> = {}
+      Object.keys(origem).forEach((key) => {
+        destino[key] = limparValor(origem[key])
+      })
+      return destino
+    }
+    return valor
+  }
+
+  const saida: { [K in keyof T]: unknown } = {} as { [K in keyof T]: unknown }
+  ;(Object.keys(objeto) as Array<keyof T>).forEach((key) => {
+    saida[key] = limparValor(objeto[key])
+  })
+  return saida as LimpezaProfunda<T>
+}

package/src/utils/masks.ts

@@ -0,0 +1,19 @@
+const Masks = {
+  cpf: '###.###.###-##',
+  rg: '#######',
+  // CNPJ alfanumérico (regra 2026): 12 primeiras posições alfanuméricas
+  // (token `X` = alfanumérico maiúsculo, aceita dígito tb → numérico segue ok),
+  // os 2 últimos (dígitos verificadores) seguem numéricos (`#`).
+  cnpj: 'XX.XXX.XXX/XXXX-##',
+  telefoneFixo: '(##) ####-####',
+  telefoneCelular: '(##) # ####-####',
+  cep: '#####-###',
+  data: '##/##/####',
+  dataHora: '##/##/#### ##:##',
+  hora: '##:##',
+  renavam: '###########',
+  protocolo: '####-##-##############',
+  dinheiro: '#.###.###,##',
+}
+
+export default Masks

package/src/utils/medidas-util.ts

@@ -0,0 +1,5 @@
+import { Medidas } from '../constants/medidas-espacos'
+
+export function obterTamanho(size: keyof typeof Medidas): string {
+  return Medidas[size]
+}

package/src/utils/normalizar-label.ts

@@ -0,0 +1,9 @@
+export const normalizeLabel = (texto: string): string => {
+  if (!texto) return ''
+  let label = texto
+    .replace(/([A-Z])/g, ' $1')
+    .replace(/\s+/g, ' ')
+    .trim()
+  label = label.toLowerCase()
+  return label.charAt(0).toUpperCase() + label.slice(1)
+}

package/src/utils/scroll-elemento.ts

@@ -0,0 +1,34 @@
+/**
+ * Rola até um elemento respeitando o container de scroll do layout.
+ *
+ * Util INTERNO — de propósito fora do barrel `utils/index.ts`, pra não crescer
+ * a API pública da lib sem pedido concreto.
+ *
+ * O detalhe que justifica o arquivo: nos projetos gerados pelo CLI o scroll
+ * NÃO está no `<body>` (`html, body { overflow: hidden }` no `app.scss`, pra o
+ * header e o drawer ficarem fixos) e sim no `.q-page.container-page`. Um
+ * `scrollIntoView` cru não move nada nesse arranjo, então centralizamos no
+ * container quando ele existe e só caímos no nativo quando não existe.
+ */
+
+/** Onde o scroll realmente acontece nos layouts da lib. */
+export const CONTAINER_SCROLL_PADRAO = '.q-page.container-page'
+
+export function scrollParaElemento(
+  elemento: Element,
+  containerSeletor: string = CONTAINER_SCROLL_PADRAO,
+  comportamento: ScrollBehavior = 'smooth',
+): void {
+  const container = document.querySelector(containerSeletor)
+
+  if (container) {
+    const containerRect = container.getBoundingClientRect()
+    const alvoRect = elemento.getBoundingClientRect()
+    const offsetTop = alvoRect.top - containerRect.top + container.scrollTop
+    const centroVertical = offsetTop - containerRect.height / 2 + alvoRect.height / 2
+    container.scrollTo({ top: Math.max(0, centroVertical), behavior: comportamento })
+    return
+  }
+
+  elemento.scrollIntoView({ behavior: comportamento, block: 'center' })
+}

package/src/utils/validar-campo.ts

@@ -0,0 +1,27 @@
+export const estaVazio = (v: unknown): boolean =>
+  v === null || v === undefined || (typeof v === 'string' && v.trim() === '')
+
+export const temValor = (v: unknown): boolean => {
+  if (v === null || v === undefined) return false
+  if (typeof v === 'string') return v.trim() !== ''
+  if (typeof v === 'number' && Number.isNaN(v)) return false
+  return true
+}
+
+export const temTexto = (v?: string): boolean => typeof v === 'string' && v.trim().length > 0
+
+export const temIdValido = (v?: number): boolean => typeof v === 'number' && v > 0
+
+type TipoConstrutorDeArquivo = new (...args: never[]) => File
+
+export const ehArquivo = (v: unknown): v is File => {
+  const possuiFile = typeof globalThis !== 'undefined' && 'File' in globalThis
+  if (possuiFile) {
+    const ConstrutorArquivo = (globalThis as unknown as { File: TipoConstrutorDeArquivo }).File
+    return v instanceof ConstrutorArquivo
+  }
+  return typeof v === 'object' && v !== null && Object.prototype.toString.call(v) === '[object File]'
+}
+
+export const ehObjeto = (v: unknown): v is Record<string, unknown> =>
+  typeof v === 'object' && v !== null

package/src/utils/validar-documentos.ts

@@ -0,0 +1,86 @@
+type Regra = (val: unknown) => true | string
+
+const somenteDigitos = (valor: string): string => valor.replace(/\D+/g, '')
+const normalizar = (valor: string): string => valor.trim().toUpperCase()
+
+const REGEX_RG = {
+  cinCpf: /^\d{11}$/,
+  rgLegado: /^[0-9.\-\s]{1,20}$/,
+} as const
+
+const REGEX_CNH = {
+  renach: /^[A-Z]{2}[0-9A-Z]{9}$/,
+  somenteDigitos: /^\d{5,15}$/,
+} as const
+
+const REGEX_TITULO = {
+  numero: /^\d{12}$/,
+  zona: /^\d{1,4}$/,
+  secao: /^\d{1,5}$/,
+} as const
+
+const REGEX_CTPS = {
+  digitalCpf: /^\d{11}$/,
+  numeroFisico: /^\d{7}$/,
+  serieFisico: /^\d{4}$/,
+} as const
+
+const REGEX_PIS = {
+  numero: /^\d{11}$/,
+} as const
+
+const REGEX_RESERVISTA = {
+  numero: /^\d{1,20}$/,
+} as const
+
+export const regraRgNumero: Regra = (val) => {
+  if (!val) return true
+  const str = String(val)
+  const n = normalizar(str)
+  const d = somenteDigitos(str)
+  return REGEX_RG.cinCpf.test(d) || REGEX_RG.rgLegado.test(n) || 'RG inválido'
+}
+
+export const regraCnhNumero: Regra = (val) => {
+  if (!val) return true
+  const str = String(val)
+  const n = normalizar(str)
+  const d = somenteDigitos(str)
+  return REGEX_CNH.renach.test(n) || REGEX_CNH.somenteDigitos.test(d) || 'CNH inválida'
+}
+
+export const regraTituloNumero: Regra = (val) => {
+  if (!val) return true
+  return REGEX_TITULO.numero.test(somenteDigitos(String(val))) || 'Número do título deve ter 12 dígitos'
+}
+
+export const regraTituloZona: Regra = (val) => {
+  if (!val) return true
+  return REGEX_TITULO.zona.test(somenteDigitos(String(val))) || 'Zona deve ter 1 a 4 dígitos'
+}
+
+export const regraTituloSecao: Regra = (val) => {
+  if (!val) return true
+  return REGEX_TITULO.secao.test(somenteDigitos(String(val))) || 'Seção deve ter 1 a 5 dígitos'
+}
+
+export const regraCtpsNumero: Regra = (val) => {
+  if (!val) return true
+  const d = somenteDigitos(String(val))
+  return REGEX_CTPS.digitalCpf.test(d) || REGEX_CTPS.numeroFisico.test(d) || 'Número da CTPS inválido'
+}
+
+export const regraCtpsSerie: Regra = (val) => {
+  if (!val) return true
+  return REGEX_CTPS.serieFisico.test(somenteDigitos(String(val))) || 'Série deve ter 4 dígitos'
+}
+
+export const regraPis: Regra = (val) => {
+  if (!val) return true
+  return REGEX_PIS.numero.test(somenteDigitos(String(val))) || 'PIS deve ter 11 dígitos'
+}
+
+export const regraReservista: Regra = (val) => {
+  if (!val) return true
+  return REGEX_RESERVISTA.numero.test(somenteDigitos(String(val))) || 'Número da reservista deve ter 1 a 20 dígitos'
+}