all_validations_br 4.0.1 copy "all_validations_br: ^4.0.1" to clipboard
all_validations_br: ^4.0.1 copied to clipboard

Published 25 days ago • verified publisheropensource.tatamemaster.com.br• Latest: 4.5.0
[unknown platforms]
→

Metadata

Dart/Flutter library for Brazilian validations (CPF, CNPJ, CNH, PIX, CEP and more), utilities (JWT, UUID, currency, dates) and authenticated encryption (ChaCha20-Poly1305).

More...

All Validations BR

💡 Validações brasileiras, utilitários e criptografia autenticada — tudo em uma única biblioteca Dart/Flutter, sem dependências externas.

🚀 Descrição do Projeto #

AllValidations BR é uma biblioteca Dart/Flutter com três pilares:

  • Validações brasileiras — CPF, CNPJ, CNH, RENAVAM, PIS/PASEP, Título de Eleitor, chaves PIX, telefones, CEP, placas, EAN-13 e muito mais.
  • Utilitários — formatação de moeda, datas, texto, JWT, UUID v3/v4/v5, HTML, PIX e informações de dispositivo.
  • Criptografia autenticada — implementação Dart pura de ChaCha20-Poly1305 (RFC 8439), com geração segura de chaves, serialização em base64 e detecção automática de adulteração.

📱 App de Exemplo #

O diretório example/ contém um app Flutter interativo que demonstra as principais funcionalidades da biblioteca.

Para rodar:

cd example
flutter pub get
flutter run

O app está dividido em seções:

Seção O que demonstra
AllValidations — CPF Validação de CPFs válidos, inválidos e formatados
HelperUtil — utilitários gerais countWords, removeHtmlTags, capitalizeWords, formatCurrency, daysBetween, generateUUIDv4, validatePixKey, maskPixKey
CryptUtil — interativo Botão "Encriptar / Decriptar" exibe ciphertext em base64 e o texto recuperado; botão "Simular adulteração" demonstra a detecção de CryptException
CryptUtil — estáticos Round-trip encryptText → decryptText com exibição da tag Poly1305 em hex

⚙️ Funcionalidades #

  • Validações Gerais
  • Verificação de tipos e formatos:
    • isNull, isNum, isNumericOnly, isNumericFloat
    • isAlphabetOnly, isLowercase, isUppercase
    • isUUID, isJSON, isHexadecimal
    • isEmail, isURL
  • Validações específicas:
    • isCpf, isCnpj, isCnpjAlphanumeric (novo formato 2026), isRG, isValidBRZip
    • isBrazilianCellPhone, isBrazilianLandline
    • isLeapYear, isValidBrazilianLicensePlate
    • Validação de código de barras EAN-13: isValidEAN13
    • Validação de cores hexadecimais: isValidHexColor
    • Validação de chaves PIX: CPF, e-mail, celular e chave aleatória

Manipulação de Texto #

  • Remoção de caracteres especiais:
    • removeCharacters, removeNonNumeric, removeAccents
  • Formatação de dados:
    • CPF: 123.456.789-09
    • CNPJ: 12.345.678/0001-95
    • Celular: (11) 99999-9999
    • Moeda: R$ 1.234,56
    • Data e hora: 01/01/2023, 12:30:45
  • Outras manipulações:
    • Comparação de frases: isPhraseEqual
    • Capitalização de palavras: capitalizeWords

Utilidades para Datas #

  • Conversões de horário:
    • UTC para local: convertUtcToLocal
    • Local para UTC: convertLocalToUtc
  • Cálculos com datas:
    • Diferença entre duas datas: daysBetween
    • Dias úteis entre duas datas: businessDaysBetween
    • Cálculo de idade: calculateAge

Funções Avançadas #

  • Validações por Regex:

    • E-mails, URLs, UUIDs, senhas fortes

  • Geração e manipulação:

    • Strings aleatórias: generateRandomString
    • Números aleatórios: generateRandomInt
    • Formatação de moeda: formatCurrency
    • Removedor Tags Html: removeHtmlTags

  • Geração de UUID:

    • generateUUIDv3 - Baseado em namespace e nome com MD5

    • generateUUIDv4 - UUID gerado aleatoriamente

    • generateUUIDv5 - Baseado em namespace e nome com SHA-1

    • Manipulação de JWT:

    • decodeJWT - Decodifica um JSON Web Token (JWT) e retorna o payload

    • isJwtExpired - Verifica se o token JWT está expirado

    • hasJwtClaim - Verifica se uma chave específica existe no JWT

    • getJwtClaim - Obtém o valor de uma chave específica no JWT

  • Informações do dispositivo:

    • Sistema operacional e versão do Dart: getDeviceInfo

  • Result — Programação Orientada a Trilhos

    • Result<F, S>: tipo funcional Success/Failure sem exceções
    • Encadeamento: .map(), .then(), .fold(), .recover()
    • Async: Result.tryAsync(), extensão FutureResult
    • Integração com Contract: .toResult(), .toResultFirst(), .toResultAsync()
    • Validações pontuais: AllValidations.validateCPF(), validateEmail(), validatePixKey(), etc.

  • Formatação de documentos e dados BR — BrFormatter

    • Geração de CPF e CNPJ válidos: generateCpf, generateCnpj
    • Formatação: formatCpf, formatCnpj, formatCep, formatPhone, formatCurrency, formatKm
    • Strip de máscaras: stripCpf, stripCnpj, stripCep, stripPhone, stripCurrencySymbol
    • Parse de moeda: parseCurrency ('R$ 1.234,56' → 1234.56)
    • Extração de DDD: extractDdd

  • Datas e horas — BrData (sem dependência do pacote intl)

    • Formatação: format, formatMonthYear, formatDayMonth, formatTime, formatTimeShort
    • Parse: parse ('DD/MM/AAAA' → DateTime), parseWithTime
    • Validação: validate (incluindo anos bissextos e meses com 30/31 dias)

  • Máscaras de campo (TextInputFormatter) — BrInputMask

    • CpfMask — 999.999.999-99
    • CnpjMask — 99.999.999/9999-99
    • CnpjAlfaMask — AA.BBB.CCC/DDDD-VV (alfanumérico 2026)
    • PhoneMask — (99) 9999-9999 / (99) 99999-9999 (fixo/celular dinâmico)
    • CepMask — 99999-999
    • DateMask — 99/99/9999
    • TimeMask — 99:99
    • CurrencyMask — R$ 9.999,99 (centavos da direita para a esquerda)
    • CardMask — 9999 9999 9999 9999
    • CardExpiryMask — 99/99

  • Criptografia básica (HelperUtil)

    • Criptografa senhas e realiza validações com as funções encryptPassword e validatePassword

  • Criptografia autenticada — ChaCha20-Poly1305 (CryptUtil)

    • Implementação Dart pura do algoritmo AEAD ChaCha20-Poly1305 (RFC 8439)
    • encryptText / decryptText — cifra e decifra strings UTF-8
    • encryptBytes / decryptBytes — cifra e decifra dados binários
    • encryptToBase64 / decryptFromBase64 — serialização como string única
    • generateKey / generateNonce — geração segura via Random.secure

🧪 Exemplos de Uso #

Validação de Parâmetros #

class TestParameters extends ValidationNotifiable {
  final String name;
  final String email;

  TestParameters({
    required this.name,
    required this.email,
  }) {
    addNotifications(Contract()
        .hasMinLen(name, 2, 'TestParameters.Name',
            "Nome deve ter no mínimo 2 caracteres!")
        .isEmail(email, "TestParameters.Email", "Email deve ser preenchido!"));
  }
}

void main() {
  final testParameters = TestParameters(email: "exemplo@teste.com", name: "c");

  if (testParameters.isValid) {
    print("Válido");
  } else {
    print("Inválido");
    testParameters.notifications.forEach((f) => print(f.message));
  }
}

Validação de CPF #

var isCpf = AllValidations.isCpf("000.000.000-00"); 
// Retorna false

Validação de Cores Hexadecimais #

bool isValidColor = AllValidations.isValidHexColor('#FF5733');
// Retorna: true;

Contagem de Palavras em uma String #

int totalWords = HelperUtil.countWords('Flutter é incrível');
// Retorna: 3

Remoção de Tags HTML #

String cleanText = HelperUtil.removeHtmlTags('<p>Hello <b>World</b></p>');
// Retorna: Hello World

Remoção de Caracteres #

var remover = AllValidations.removeCharacters("000.000.000-00"); 
// Retorna: 00000000000

Comparação de Senhas ou Frases #

var comparacao = AllValidations.isPhraseEqual("123456789", "123456789");
// Retorna: true

Geração de UUIDs #

String uuid4 = HelperUtil.generateUUIDv4();
// Exemplo de saída: '550e8400-e29b-41d4-a716-446655440000'

Lista de Dias da Semana #

var diasDaSemana = AllValidationsGetWeek.listDaysWeekAbvr;
// Retorna: ['Segunda', 'Terça', 'Quarta', 'Quinta', 'Sexta', 'Sábado', 'Domingo']

Remoção de Acentos e Caracteres Especiais #

var texto = AllValidations.removeAccents("áãé");
// Retorna: aae

Função para Retornar o Estado pelo DDD #

print(AllValidations.getStateByDDD("11")); 
// Saída: BrazilianState.SP

🔒 Criptografia Autenticada — CryptUtil #

CryptUtil implementa ChaCha20-Poly1305 (RFC 8439) em Dart puro, sem dependências externas. O algoritmo é AEAD (Authenticated Encryption with Associated Data): garante confidencialidade e integridade em uma única operação. Qualquer adulteração nos dados — seja no ciphertext, na tag ou no nonce — é detectada automaticamente.

Uso básico — texto #

import 'package:all_validations_br/all_validations_br.dart';

// 1. Gera uma chave de 32 bytes (guarde em armazenamento seguro)
final key = CryptUtil.generateKey();

// 2. Criptografa
final payload = CryptUtil.encryptText('Dados sensíveis', key: key);

// 3. Decriptografa
final texto = CryptUtil.decryptText(payload);
print(texto); // 'Dados sensíveis'

Uso básico — bytes #

final data = [1, 2, 3, 4, 5];
final key  = CryptUtil.generateKey();

final payload      = CryptUtil.encryptBytes(data, key: key);
final List<int> restored = CryptUtil.decryptBytes(payload);

Serialização (armazenamento / transmissão) #

O EncryptedPayload pode ser serializado para JSON ou para uma string base64 compacta.

// Serializa como string base64 (ideal para SharedPreferences, banco, API)
final encoded = CryptUtil.encryptToBase64('secreto', key: key);

// Restaura e decriptografa
final original = CryptUtil.decryptFromBase64(encoded);

// Ou via JSON
final json    = payload.toJson();          // Map<String, dynamic>
final payload2 = EncryptedPayload.fromJson(json);

Com AAD (Additional Authenticated Data) #

AAD é autenticado mas não cifrado — útil para vincular metadados ao ciphertext. Se o AAD for alterado na decriptação, um CryptException é lançado.

import 'dart:convert';

final aad     = utf8.encode('user_id:42');
final payload = CryptUtil.encryptText('dado privado', key: key, aad: aad);

// Decriptografa normalmente (AAD está no payload)
final texto = CryptUtil.decryptText(payload);

Detecção de adulteração #

try {
  final texto = CryptUtil.decryptText(payload);
} on CryptException catch (e) {
  // Dados corrompidos ou chave/nonce incorretos
  print(e); // CryptException: Tag de autenticação inválida.
}

Referência da API #

Método Descrição
CryptUtil.encryptText(text, {key?, nonce?, aad?}) Cifra uma String e retorna EncryptedPayload
CryptUtil.decryptText(payload) Decifra e retorna a String original
CryptUtil.encryptBytes(bytes, {key?, nonce?, aad?}) Cifra bytes e retorna EncryptedPayload
CryptUtil.decryptBytes(payload) Decifra e retorna List<int>
CryptUtil.encryptToBase64(text, {key?, nonce?, aad?}) Cifra e serializa como String base64
CryptUtil.decryptFromBase64(encoded) Deserializa e decifra de String base64
CryptUtil.generateKey() Gera chave de 32 bytes (Random.secure)
CryptUtil.generateNonce() Gera nonce de 12 bytes (Random.secure)

Boas práticas #

  • Armazene a chave em flutter_secure_storage ou equivalente — nunca em SharedPreferences em texto puro.
  • Não reutilize o mesmo par (key, nonce) para dados diferentes. Por padrão, um nonce aleatório é gerado a cada chamada de encryptText/encryptBytes.
  • Trate CryptException sempre — indica dados adulterados ou chave incorreta.

🚦 Result — Programação Orientada a Trilhos #

Result<F, S> é um tipo que representa o resultado de uma operação que pode falhar. Em vez de lançar exceções ou retornar null, você devolve Success(valor) ou Failure(erro) — e encadeia as transformações de forma segura.

Inspirado no Result de Rust, Swift e Kotlin Arrow — amplamente reconhecido no mercado.

import 'package:all_validations_br/all_validations_br.dart';

Criando um Result #

// Sucesso
Result<String, int> ok = Result.success(42);

// Falha
Result<String, int> err = Result.failure('valor inválido');

// Baseado em condição
Result<String, int> r = Result.cond(cpf.length == 11, cpf, 'CPF deve ter 11 dígitos');

// Capturando exceções de forma funcional
Result<String, int> r = Result.guard(
  () => int.parse(input),
  onError: (e) => 'Não é um número',
);

Transformando o valor #

final result = Result.success<String, int>(5)
    .map((n) => n * 2)           // Success(10)
    .map((n) => 'Valor: $n');    // Success('Valor: 10')

// map não executa em Failure — o erro propaga automaticamente
Result.failure<String, int>('err').map((n) => n * 2); // Failure('err')

// mapFailure — transforma o lado do erro
Result.failure<int, String>(404).mapFailure((code) => 'Erro $code');

Encadeamento com .then() (flatMap / railway) #

Result<String, String> validarCPF(String cpf) { ... }
Result<String, User>   buscarUsuario(String cpf) { ... }

final result = validarCPF('529.982.247-25')
    .then((cpf) => buscarUsuario(cpf))
    .map((user) => 'Olá, ${user.nome}');

// Se qualquer etapa falhar, o Failure se propaga automaticamente
// — nenhuma etapa seguinte é executada.

Consumindo o resultado com .fold() #

final mensagem = result.fold(
  (erro)  => 'Falha: $erro',    // executado em Failure
  (valor) => 'Ok: $valor',      // executado em Success
);

Outros métodos utilitários:

result.isSuccess;              // bool
result.isFailure;              // bool
result.successValue;           // valor (lança StateError em Failure)
result.failureValue;           // erro  (lança StateError em Success)

result.getOrElse(0);           // valor ou default
result.getOrCall((err) => -1); // valor ou resultado de fn
result.toNullable();           // valor ou null
result.recover((err) => -1);  // converte Failure em Success
result.swap();                 // inverte Success ↔ Failure

Operações assíncronas #

Envolva chamadas HTTP, banco de dados ou qualquer Future que possa falhar:

final result = await Result.tryAsync<String, User>(
  () => api.getUser(id),
  onError: (e, stack) => 'Falha na requisição: $e',
);

Capturando apenas um tipo específico de exceção:

final result = await Result.tryAsyncTyped<DioException, String, User>(
  () => dio.get('/user/$id'),
  onError: (e, _) => 'HTTP ${e.response?.statusCode}',
);

Chain completo — exemplo real (HTTP + parse + validação)

final mensagem = await Result.tryAsync<String, String>(
  () => http.read(Uri.parse('https://api.exemplo.com/cpf/$cpf')),
  onError: (e, _) => 'Falha na requisição',
)
.thenAsync((raw) async => parseJson(raw))
.thenAsync((json) async => AllValidations.validateCPF(json['cpf']))
.foldAsync(
  (erro)  async => 'Erro: ${erro.message}',
  (cpfOk) async => 'CPF válido: $cpfOk',
);

Extensões disponíveis em Future<Result<F, S>>:

Método Descrição
mapAsync(fn) Transforma o valor em async
thenAsync(fn) Encadeia outro Future<Result>
foldAsync(onF, onS) Consome ambos os lados em async
recoverAsync(fn) Converte Failure em Success em async
tapAsync(fn) Side-effect em Success (sem alterar o valor)
tapFailureAsync(fn) Side-effect em Failure (sem alterar o erro)
getOrElse(default) Valor ou default
toNullable() Valor ou null

Integração com Contract #

Todos os métodos de validação de Contract retornam ContractValidations — basta chamar .toResult() no final do chain:

// Retorna todas as notificações de erro em caso de falha
final result = Contract()
    .requires()
    .isValidCPF(cpf, 'cpf', 'CPF inválido')
    .isEmail(email, 'email', 'E-mail inválido')
    .toResult(UserDto(cpf: cpf, email: email));

result.fold(
  (erros) => erros.forEach((e) => print('${e.property}: ${e.message}')),
  (user)  => salvarUsuario(user),
);

// Retorna apenas o primeiro erro
final result = contract.toResultFirst(dto);
result.fold(
  (erro) => showSnackbar(erro.message),
  (dto)  => save(dto),
);

// Versão async — valueFn só é chamada se o contrato for válido
final result = await contract.toResultAsync(() async => await fetchUser(id));

ValidationResult<T> é um typedef pronto para o caso mais comum:

// equivale a Result<List<ValidationNotification>, T>
ValidationResult<UserDto> validate(UserDto dto) {
  return Contract()
      .requires()
      .isEmail(dto.email, 'email', 'E-mail inválido')
      .toResult(dto);
}

AllValidations.validate*() — validações pontuais com Result #

Para validar um campo isolado sem precisar de Contract:

// CPF — Success carrega os dígitos normalizados
AllValidations.validateCPF('529.982.247-25');
// Success('52998224725')

// E-mail — Success carrega em lowercase
AllValidations.validateEmail('Carlos@Exemplo.COM');
// Success('carlos@exemplo.com')

// Failure carrega ValidationError com property e message
AllValidations.validateCPF('000.000.000-00');
// Failure(ValidationError(property: 'cpf', message: 'CPF inválido.'))

// Customizando property/message
AllValidations.validateCPF('invalido', property: 'documento', message: 'Documento inválido');

Métodos disponíveis:

Método Success carrega
validateCPF(cpf) dígitos normalizados
validateCNPJ(cnpj) dígitos normalizados
validateEmail(email) email em lowercase
validateCEP(cep) dígitos normalizados
validateCellPhone(phone) valor original
validateLandline(phone) valor original
validateCNH(cnh) dígitos normalizados
validateRENAVAM(renavam) dígitos normalizados
validatePIS(pis) dígitos normalizados
validateTituloEleitor(titulo) dígitos normalizados
validateRG(rg) valor original
validateLicensePlate(plate) placa em maiúsculas
validateURL(url) valor original
validateUUID(uuid) valor original
validateStrongPassword(pass) valor original
validateCreditCard(number) dígitos normalizados
validatePixKey(key) tipo: 'CPF', 'Celular', 'Email', 'Chave Aleatória'

Verificação de Chaves em Mapas JSON #

Map<String, dynamic> map1 = {"status": "success", "message": "successfully logged out"};

bool existe = AllValidations.isMapExists(map: map1, key: ['status']);
// Retorna: true

Validação de Chaves PIX #

HelperUtil.validatePixKey identifica o tipo da chave PIX informada, seguindo a ordem de validação definida pelo BACEN:

  1. CPF — 11 dígitos com dígitos verificadores válidos (aceita formato com ou sem máscara)
  2. Celular — formato E.164: +55 + DDD + número começando com 9 (ex: +5511912345678)
  3. E-mail — endereço de e-mail válido
  4. Chave aleatória — UUID v4 (ex: 123e4567-e89b-4d3a-a456-426614174000)

Otimização: se o valor contiver apenas dígitos, e-mail e chave aleatória são descartados imediatamente.

// CPF (com ou sem máscara)
HelperUtil.validatePixKey('992.864.791-74'); // 'CPF'
HelperUtil.validatePixKey('99286479174');    // 'CPF'

// Celular — obrigatório formato E.164
HelperUtil.validatePixKey('+5511912345678'); // 'Celular'

// E-mail
HelperUtil.validatePixKey('user@example.com'); // 'Email'

// Chave aleatória — UUID v4
HelperUtil.validatePixKey('123e4567-e89b-4d3a-a456-426614174000'); // 'Chave Aleatória'

// Inválido
HelperUtil.validatePixKey('12345678901'); // null

Mascaramento de Chave PIX #

HelperUtil.maskPixKey('99286479174');                        // '992.***.***-74'
HelperUtil.maskPixKey('+5511912345678');                     // '+5511*****678'
HelperUtil.maskPixKey('user@example.com');                   // 'us**@example.com'
HelperUtil.maskPixKey('123e4567-e89b-4d3a-a456-426614174000'); // '123e4567-****-****-****-426614174000'

CNPJ Alfanumérico 2026 — CnpjAlfanumerico #

A partir de julho de 2026, a Receita Federal passa a emitir CNPJs com letras maiúsculas (A–Z) nos 12 primeiros caracteres, conforme a IN RFB 2229/2024. Os 2 dígitos verificadores continuam sendo sempre numéricos.

Formato: AA.BBB.CCC/DDDD-VV

Validação #

// Aceita CNPJ numérico legado (retrocompatível)
CnpjAlfanumerico.isValid('11.222.333/0001-81'); // true

// Aceita CNPJ alfanumérico 2026 (com ou sem máscara)
CnpjAlfanumerico.isValid('AB.1CD.2EF/3GHI-45'); // true
CnpjAlfanumerico.isValid('AB1CD2EF3GHI45');      // true (sem máscara)

// Atalho via AllValidations
AllValidations.isCnpjAlphanumeric('AB.1CD.2EF/3GHI-45'); // true

Formatação e strip #

// Aplica a máscara XX.XXX.XXX/XXXX-VV
CnpjAlfanumerico.format('AB1CD2EF3GHI45'); // 'AB.1CD.2EF/3GHI-45'

// Remove a máscara (preserva [A-Z0-9], converte para maiúsculas)
CnpjAlfanumerico.strip('ab.1cd.2ef/3ghi-45'); // 'AB1CD2EF3GHI45'

Geração (útil para testes) #

// CNPJ alfanumérico ou numérico aleatório válido
final cnpj = CnpjAlfanumerico.generate();
// Ex.: 'K7B3X19QAC0234'

// Com máscara
final formatado = CnpjAlfanumerico.generate(formatted: true);
// Ex.: 'K7.B3X.19Q/AC02-34'

// Garante ao menos uma letra nos 12 primeiros caracteres
final alfanumerico = CnpjAlfanumerico.generate(forceAlphanumeric: true);

Correção de bug do brasil_fields: o brasil_fields usa codeUnit - 48 para converter todos os caracteres, gerando valores errados para letras (A → 17 em vez de 10, Z → 42 em vez de 35). Nossa implementação usa codeUnit - 55 para letras maiúsculas, conforme especificado na IN RFB 2229/2024 — o que produz dígitos verificadores diferentes e corretos.

BrFormatter — formatação e geração de documentos BR #

BrFormatter é a classe central para formatar, limpar e gerar dados tipicamente brasileiros — CPF, CNPJ, CEP, telefone, moeda e quilometragem — sem nenhuma dependência externa.

CPF #

import 'package:all_validations_br/all_validations_br.dart';

// Gera um CPF válido aleatório
final cpf = BrFormatter.generateCpf();             // '52998224725'
final cpfF = BrFormatter.generateCpf(formatted: true); // '529.982.247-25'

// Formata um CPF já existente
BrFormatter.formatCpf('52998224725'); // '529.982.247-25'

// Remove a máscara
BrFormatter.stripCpf('529.982.247-25'); // '52998224725'

CNPJ numérico #

// Gera um CNPJ numérico válido aleatório
final cnpj = BrFormatter.generateCnpj();              // '11222333000181'
final cnpjF = BrFormatter.generateCnpj(formatted: true); // '11.222.333/0001-81'

// Formata / remove máscara
BrFormatter.formatCnpj('11222333000181'); // '11.222.333/0001-81'
BrFormatter.stripCnpj('11.222.333/0001-81'); // '11222333000181'

// Para CNPJ alfanumérico 2026, use CnpjAlfanumerico:
CnpjAlfanumerico.generate(forceAlphanumeric: true, formatted: true);

CEP e Telefone #

BrFormatter.formatCep('01310100');   // '01310-100'
BrFormatter.stripCep('01310-100');   // '01310100'

BrFormatter.formatPhone('11999998877');            // '(11) 99999-8877'
BrFormatter.formatPhone('1133334444');             // '(11) 3333-4444'
BrFormatter.formatPhone('11999998877', ddd: false); // '99999-8877'
BrFormatter.extractDdd('11999998877');             // '11'

Moeda #

BrFormatter.formatCurrency(1234.56);                    // 'R$ 1.234,56'
BrFormatter.formatCurrency(85437107.04);                // 'R$ 85.437.107,04'
BrFormatter.formatCurrency(1234.56, symbol: false);     // '1.234,56'
BrFormatter.formatCurrency(1234.0,  decimals: 0);       // 'R$ 1.234'

BrFormatter.parseCurrency('R$ 1.234,56');  // 1234.56
BrFormatter.stripCurrencySymbol('R$ 99,90'); // '99,90'

KM #

BrFormatter.formatKm(85437);    // '85.437 km'
BrFormatter.formatKm(1000000);  // '1.000.000 km'

Máscaras de Campo — BrInputMask #

Todas as máscaras estendem BrInputMask (que estende TextInputFormatter) e possuem const constructors — zero custo de instanciação. Basta adicioná-las ao inputFormatters do TextField.

CPF, CNPJ e CNPJ Alfanumérico 2026 #

import 'package:all_validations_br/all_validations_br.dart';

// CPF → '529.982.247-25'
TextField(
  keyboardType: TextInputType.number,
  inputFormatters: [CpfMask()],
)

// CNPJ numérico → '11.222.333/0001-81'
TextField(
  keyboardType: TextInputType.number,
  inputFormatters: [CnpjMask()],
)

// CNPJ alfanumérico 2026 → 'AB.123.CDE/0001-39'
TextField(
  keyboardType: TextInputType.text,
  textCapitalization: TextCapitalization.characters,
  inputFormatters: [CnpjAlfaMask()],
)

Telefone e CEP #

// Telefone dinâmico: (11) 3333-4444 ou (11) 99999-8877
TextField(
  keyboardType: TextInputType.phone,
  inputFormatters: [PhoneMask()],
)

// CEP → '01310-100'
TextField(
  keyboardType: TextInputType.number,
  inputFormatters: [CepMask()],
)

Data e Hora #

// Data → '26/06/2026'
TextField(
  keyboardType: TextInputType.number,
  inputFormatters: [DateMask()],
)

// Hora → '14:30'
TextField(
  keyboardType: TextInputType.number,
  inputFormatters: [TimeMask()],
)

Moeda #

// Moeda em tempo real → 'R$ 1.234,56'
// Abordagem centavos: '1' → 'R$ 0,01'; '123456' → 'R$ 1.234,56'
TextField(
  keyboardType: TextInputType.number,
  inputFormatters: [CurrencyMask()],
)

Cartão de Crédito #

// Número do cartão → '4111 1111 1111 1111'
TextField(
  keyboardType: TextInputType.number,
  inputFormatters: [CardMask()],
)

// Validade → '12/24'
TextField(
  keyboardType: TextInputType.number,
  inputFormatters: [CardExpiryMask()],
)

Referência rápida #

Classe Máscara Dígitos max
CpfMask 999.999.999-99 11
CnpjMask 99.999.999/9999-99 14
CnpjAlfaMask AA.BBB.CCC/DDDD-VV 14
PhoneMask (99) 9999-9999 / (99) 99999-9999 10/11
CepMask 99999-999 8
DateMask 99/99/9999 8
TimeMask 99:99 4
CurrencyMask R$ 9.999,99 13
CardMask 9999 9999 9999 9999 16
CardExpiryMask 99/99 4

BrData — datas e horas sem intl #

BrData oferece formatação, parse e validação de datas no padrão brasileiro (DD/MM/AAAA) implementados em Dart puro — sem precisar adicionar o pacote intl.

import 'package:all_validations_br/all_validations_br.dart';

final hoje = DateTime(2026, 7, 1, 9, 5, 3);

// Formatação
BrData.format(hoje);           // '01/07/2026'
BrData.formatMonthYear(hoje);  // '07/2026'
BrData.formatDayMonth(hoje);   // '01/07'
BrData.formatTime(hoje);       // '09:05:03'
BrData.formatTimeShort(hoje);  // '09:05'

// Parse
final dt = BrData.parse('26/06/2026');
// DateTime(2026, 6, 26)

final dtHora = BrData.parseWithTime('26/06/2026 14:30');
// DateTime(2026, 6, 26, 14, 30)

// Validação (inclui anos bissextos e meses com 30/31 dias)
BrData.validate('29/02/2024'); // true  (2024 é bissexto)
BrData.validate('29/02/2023'); // false (2023 não é bissexto)
BrData.validate('31/04/2026'); // false (abril tem 30 dias)

Validação de Documentos Brasileiros #

// CNH
AllValidations.isCnh('84718735264'); // true

// RENAVAM (aceita 9 ou 11 dígitos)
AllValidations.isRenavam('95606520941'); // true

// PIS/PASEP
AllValidations.isPisPasep('12345678919'); // true

// Título de Eleitor
AllValidations.isTituloEleitor('006000610949'); // true

TextEditingController com dados pré-formatados #

Para inicializar um TextEditingController com o texto já formatado, use os métodos de formatação da biblioteca diretamente no atributo text:

import 'package:all_validations_br/all_validations_br.dart';

// CPF → '529.982.247-25'
final cpfController = TextEditingController(
  text: BrFormatter.formatCpf('52998224725'),
);

// CNPJ numérico → '11.222.333/0001-81'
final cnpjController = TextEditingController(
  text: BrFormatter.formatCnpj('11222333000181'),
);

// CNPJ alfanumérico 2026 → 'AB.1CD.2EF/0001-99'
final cnpjAlfaController = TextEditingController(
  text: CnpjAlfanumerico.format('AB1CD2EF000199'),
);

// Celular → '(11) 99999-8877'
final celularController = TextEditingController(
  text: BrFormatter.formatPhone('11999998877'),
);

// CEP → '01310-100'
final cepController = TextEditingController(
  text: BrFormatter.formatCep('01310100'),
);

// Data → '31/12/2024'
final dataController = TextEditingController(
  text: BrData.format(DateTime(2024, 12, 31)),
);

// Moeda → 'R$ 1.234,56'
final valorController = TextEditingController(
  text: BrFormatter.formatCurrency(1234.56),
);

Validação de Data e Maioridade #

// Verifica se a data existe de verdade
HelperUtil.isValidDate('31/02/2023'); // false
HelperUtil.isValidDate('15/06/2023'); // true
HelperUtil.isValidDate('2023-06-15'); // true

// Verifica maioridade (padrão 18 anos, customizável)
HelperUtil.isAdult(DateTime(2000, 1, 1));           // true
HelperUtil.isAdult(DateTime(2010, 1, 1));           // false
HelperUtil.isAdult(DateTime(2002, 1, 1), minAge: 21); // false

📖 Documentação e Wiki #

Para mais detalhes sobre o uso da biblioteca, acesse nossa Wiki.

🆘 Classes para Uso #

Aqui estão as principais classes disponíveis na biblioteca AllValidations BR, juntamente com suas funcionalidades para facilitar a validação e manipulação de dados em seus projetos Flutter.

HelperUtil #

Utilitários diversos para manipulação e formatação de dados, incluindo:

  • Decodificação de JWT
  • Geração de strings e números aleatórios
  • Conversão de datas entre UTC e horário local
  • Formatação de valores para moeda brasileira
  • Remoção de tags HTML de strings
  • Geração de UUIDs (v3, v4 e v5)
  • Criptografia e validação de senhas
  • Validação de chaves PIX (CPF, Celular, E-mail, Chave Aleatória)

CnpjAlfanumerico #

Suporte completo ao novo formato de CNPJ alfanumérico (IN RFB 2229/2024, vigência jul/2026).

  • isValid(cnpj) — valida CNPJ numérico legado ou alfanumérico 2026
  • format(cnpj) — aplica a máscara AA.BBB.CCC/DDDD-VV
  • strip(cnpj) — remove a máscara, preservando [A-Z0-9]
  • generate({formatted, forceAlphanumeric}) — gera CNPJ válido aleatório

BrFormatter #

Utilitários de formatação, limpeza e geração para dados tipicamente brasileiros — sem dependências externas.

  • CPF: generateCpf({formatted}), formatCpf(cpf), stripCpf(cpf)
  • CNPJ numérico: generateCnpj({formatted}), formatCnpj(cnpj), stripCnpj(cnpj)
  • CEP: formatCep(cep), stripCep(cep)
  • Telefone: formatPhone(phone, {ddd}), extractDdd(phone), stripPhone(phone)
  • Moeda: formatCurrency(value, {symbol, decimals}), parseCurrency(value), stripCurrencySymbol(value)
  • KM: formatKm(km)

BrData #

Formatação e parse de datas e horas no padrão brasileiro, implementados em Dart puro (sem intl).

  • format(dt) → 'DD/MM/AAAA'
  • formatMonthYear(dt) → 'MM/AAAA'
  • formatDayMonth(dt) → 'DD/MM'
  • formatTime(dt) → 'HH:MM:SS'
  • formatTimeShort(dt) → 'HH:MM'
  • parse(date) → DateTime de 'DD/MM/AAAA'
  • parseWithTime(dateTime) → DateTime de 'DD/MM/AAAA HH:MM'
  • validate(date) → bool (valida bissextos e dias por mês)

BrInputMask e subclasses #

Formatters de campo (TextInputFormatter) para máscaras brasileiras em tempo real. Todas têm const constructor.

Classe Máscara
CpfMask 999.999.999-99
CnpjMask 99.999.999/9999-99
CnpjAlfaMask AA.BBB.CCC/DDDD-VV (2026)
PhoneMask (99) 9999-9999 / (99) 99999-9999
CepMask 99999-999
DateMask 99/99/9999
TimeMask 99:99
CurrencyMask R$ 9.999,99
CardMask 9999 9999 9999 9999
CardExpiryMask 99/99

AllValidations #

Conjunto de funções para validar diferentes tipos de dados, como:

  • CPF, CNPJ numérico (isCnpj) e CNPJ alfanumérico 2026 (isCnpjAlphanumeric)
  • E-mail e URL
  • Telefone brasileiro (fixo e celular)
  • CEP, RG e outras identificações
  • Formatos de data, IP e JSON

Contract #

Classe para gerenciamento de contratos de validação, permitindo a criação de regras flexíveis e reutilizáveis para validar dados com notificações de erro detalhadas.

  • Definição de regras de validação personalizada
  • Verificação de requisitos obrigatórios e condições específicas
  • Emissão de notificações de erro em propriedades inválidas
  • Conversão direta para Result via .toResult(), .toResultFirst(), .toResultAsync()

Result<F, S> #

Tipo funcional para representar o resultado de uma operação que pode falhar, eliminando exceções e null do fluxo de negócio.

  • Result.success(value) / Result.failure(error) — construtores básicos
  • Result.guard / Result.tryAsync — captura exceções de forma funcional
  • .map(), .then(), .fold(), .recover() — transformações encadeadas
  • Extensões async via FutureResult para operações HTTP, banco e cache
  • ValidationResult<T> — alias para Result<List<ValidationNotification>, T>

AllValidationsGetMonth #

Fornece listas de nomes dos meses do ano para fácil acesso e manipulação.

  • Exemplo de uso: AllValidationsGetMonth.list → [Janeiro, Fevereiro, ...]

AllValidationsGetRegions #

Retorna as regiões do Brasil, útil para aplicações que necessitam de categorização geográfica.

  • Exemplo de uso: AllValidationsGetRegions.list → [Norte, Nordeste, ...]

AllValidationsGetStates #

Disponibiliza os estados brasileiros e suas siglas.

  • Exemplo de uso: AllValidationsGetStates.list → [SP, RJ, MG, ...]

AllValidationsGetWeek #

Fornece listas de dias da semana em formato abreviado e completo.

  • Exemplo de uso: AllValidationsGetWeek.listDaysWeekAbvr → [Seg, Ter, Qua, ...]

🤝 Contribuições #

Contributors

Made with contrib.rocks.

Encontrou algum problema ou tem sugestões para melhorar a biblioteca? Contribua abrindo uma issue no nosso repositório oficial do GitHub!

  • 🔗 All Validations BR — GitHub

📦 Instalação #

Adicione a dependência ao seu arquivo pubspec.yaml: #

dependencies: all_validations_br:

📜 Licença #

Este projeto está sob a licença MIT.

💻 Desenvolvido com ❤️ para facilitar o desenvolvimento no Flutter.

← Metadata

98
likes
0
points
1.45k
downloads

Publisher

verified publisheropensource.tatamemaster.com.br

Weekly Downloads

Metadata

Dart/Flutter library for Brazilian validations (CPF, CNPJ, CNH, PIX, CEP and more), utilities (JWT, UUID, currency, dates) and authenticated encryption (ChaCha20-Poly1305).

Repository (GitHub)
View/report issues

License

unknown (license)

Dependencies

flutter

More

Packages that depend on all_validations_br

Back