validation-br 1.6.0-a → 1.6.0-b

package/.prettierignore

@@ -0,0 +1 @@
+dist/

package/.prettierrc.js

@@ -0,0 +1,7 @@
+module.exports = {
+  semi: true,
+  trailingComma: 'all',
+  singleQuote: true,
+  printWidth: 100,
+  tabWidth: 2,
+}

package/eslint.config.js

@@ -0,0 +1,82 @@
+module.exports = {
+  // root: true,
+  // extends: ['airbnb-base', 'prettier'],
+  // parserOptions: {
+  //   ecmaVersion: 2018,
+  //   sourceType: 'module',
+  // },
+  // env: {
+  //   node: true,
+  //   jest: true,
+  // },
+  settings: {
+    'import/resolver': {
+      node: {
+        extensions: ['.js', '.ts'],
+      },
+    },
+  },
+  rules: {
+    // '@typescript-eslint/no-unused-vars': ['error', { varsIgnorePattern: '^_', args: 'none' }],
+    'array-callback-return': 'off',
+    'arrow-body-style': 'off',
+    curly: ['error', 'multi-line', 'consistent'],
+    'class-methods-use-this': 'off',
+    'consistent-return': 'warn',
+    'default-case': 'off',
+    // 'import/extensions': ['error', 'never'],
+    // 'import/first': 'warn',
+    // 'import/no-named-as-default': 'warn',
+    // 'import/no-named-as-default-member': 'warn',
+    // 'import/no-unresolved': 'warn',
+    // 'import/prefer-default-export': 'off',
+    'lines-between-class-members': ['error', 'always', { exceptAfterSingleLine: true }],
+    'max-classes-per-file': 'off',
+    'max-len': ['error', 120, 2, { ignoreUrls: true, ignoreTemplateLiterals: true }],
+    'newline-per-chained-call': 'warn',
+    'no-await-in-loop': 'off',
+    'no-confusing-arrow': 'off',
+    'no-console': 'off',
+    'no-continue': 'off',
+    'no-else-return': ['error', { allowElseIf: true }],
+    'no-loop-func': 'off',
+    'no-mixed-operators': 'off',
+    'no-nested-ternary': 'off',
+    // 'no-only-tests/no-only-tests': 'error',
+    'no-param-reassign': 'off',
+    'no-plusplus': 'off',
+    'no-prototype-builtins': 'off',
+    'no-restricted-syntax': 'off',
+    'no-return-assign': 'warn',
+    'no-sequences': 'warn',
+    'no-shadow': 'off',
+    'no-underscore-dangle': 'off',
+    'no-unexpected-multiline': 'off',
+    'no-unused-vars': 'off',
+    'no-use-before-define': ['warn', { functions: false, classes: false }],
+    'prefer-destructuring': 'off',
+    semi: ['error', 'always'],
+    'sort-imports': 'off',
+    'no-unused-expressions': 'off',
+    quotes: ['error', 'single', { avoidEscape: true }],
+    // '@typescript-eslint/ban-types': 'error',
+  },
+  // overrides: [
+  //   {
+  //     files: ['*.ts'],
+  //     rules: {
+  //       'no-dupe-class-members': 'off',
+  //       'no-undef': 'off',
+  //       '@typescript-eslint/explicit-function-return-type': 'error',
+  //     },
+  //   },
+  //   {
+  //     files: ['*.d.ts'],
+  //     rules: {
+  //       'no-useless-constructor': 'off', // crashes on constructor declaration in .d.ts files
+  //     },
+  //   },
+  // ],
+  // plugins: ['no-only-tests', '@typescript-eslint'],
+  ignores: ['dist/*', '/node_modules/**'],
+};

package/jest.config.js

@@ -0,0 +1,11 @@
+module.exports = {
+  moduleFileExtensions: ['ts', 'js'],
+  transform: {
+    '^.+\\.(ts|tsx)$': ['ts-jest', { /* ts-jest config goes here in Jest */ }],
+  },
+  testRegex: '(/test/.*\\.(test|spec))\\.(jsx?|tsx?)$',
+  testEnvironment: 'node',
+  coverageDirectory: './coverage/',
+  collectCoverage: true,
+  coverageProvider: 'v8',
+}

package/package.json

@@ -1,12 +1,9 @@
 {
   "name": "validation-br",
   "description": "Brazilian personal documents validation - cpf, cnpj, titulo, pis/pasep, cnh, renavam, processos judiciais, protocolo federal, código de rastreamento dos correios",
-  "version": "1.6.0-a",
+  "version": "1.6.0-b",
   "main": "dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
   "author": "Cláudio Medeiros <klawdyo@gmail.com>",
   "license": "MIT",
   "scripts": {

package/test/cnh.test.ts

@@ -0,0 +1,113 @@
+import isCNH, { dv, fake, mask, normalize, validate, validateOrFail } from '../src/cnh';
+import * as _cnh from '../src/cnh';
+
+describe('CNH', () => {
+  test.each([
+    // como inteiro
+    50195131143,
+    58316794534,
+    50195471165,
+    // como string
+    '69044271146',
+    '46190906839',
+    // com máscara
+    '624729276-37',
+  ])('isCNH() - Números válidos', (item) => {
+
+    expect(isCNH(item)).toBeTruthy();
+    expect(_cnh.validate(item)).toBeTruthy();
+
+
+  });
+
+  test.each([
+    // como inteiro
+    50195131143,
+    58316794534,
+    // como string
+    '69044271146',
+    '46190906839',
+    // com máscara
+    '624729276-37',
+  ])('validate() - Números válidos', (item) => {
+
+    // t.true(isCNH(cnh), `CNH ${cnh} deve ser válida`)
+    expect(validate(item)).toBeTruthy();
+  });
+
+  test.each([
+    // 
+    '50195471143',
+    '58316474534',
+    '69044471146',
+    '33333333333',
+    '88888888888'
+  ])('validate() - Números inválidos', (item) => {
+
+    expect(validate(item)).toBeFalsy();
+
+  });
+
+  test.each(['50195471143', '58316474534', '69044471146', '33333333333', '88888888888'])('validateOrFail() - Números inválidos', (item) => {
+    expect(() => validateOrFail(item)).toThrow();
+  });
+
+  test('Parâmetro não informado', () => {
+    expect(isCNH('')).toBeFalsy();
+    expect(validate('')).toBeFalsy();
+    expect(() => validateOrFail('')).toThrow();
+    expect(() => dv('')).toThrow();
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes sem máscara', () => {
+    const cnh = fake();
+    expect(validate(cnh)).toBeTruthy();
+    expect(cnh).toHaveLength(11);
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes com máscara', () => {
+    const cnh = fake(true);
+    expect(validate(cnh)).toBeTruthy();
+    expect(cnh).toHaveLength(12);
+
+  });
+
+  test.each([
+    { value: '501954711', expected: '65' },
+    { value: 583164745, expected: '75' },
+    { value: 690444711, expected: '17' },
+  ])('dv() - Verificando se o DV gerado está correto', (item) => {
+
+    const calcDv = dv(item.value);
+
+    expect(calcDv).toBe(item.expected);
+    expect(typeof calcDv).toBe('string');
+
+  });
+
+  test.each([
+    { value: 50195471143, expected: '501954711-43' },
+    { value: 58316474534, expected: '583164745-34' },
+    { value: 69044471146, expected: '690444711-46' },
+  ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {
+    const masked = mask(item.value);
+
+    expect(masked).toBe(item.expected);
+    expect(masked).toHaveLength(12);
+  });
+
+  test.each([
+    { value: '501954711-43', expected: '50195471143' },
+    { value: '583164745-34', expected: '58316474534' },
+    { value: '690444711-46', expected: '69044471146' },
+    { value: '50195471143', expected: '50195471143' },
+    { value: '58316474534', expected: '58316474534' },
+    { value: '69044471146', expected: '69044471146' },
+  ])('normalize() - Testando se remove a máscara corretamente', (item) => {
+
+    const normalized = normalize(item.value);
+
+    expect(normalized).toBe(item.expected);
+    expect(normalized).toHaveLength(11);
+  });
+});

package/test/cnpj.test.ts

@@ -0,0 +1,179 @@
+import isCNPJ, { dv, fake, mask, validate, validateOrFail, normalize } from '../src/cnpj';
+import * as _cnpj from '../src/cnpj';
+
+describe('CNPJ', () => {
+  test.each([
+    // Com máscara
+    '11.222.333/0001-81',
+    '73.797.980/0001-79',
+    '06.946.762/0001-61',
+    '96.051.576/0001-57',
+    '55.585.709/0001-98',
+    // inteiro
+    99360938000180,
+    23693443000100,
+    // string
+    '32432147000147',
+    '91951438000100',
+  ])('isCNPJ() - Números válidos', (cnpj) => {
+    expect(isCNPJ(cnpj)).toBeTruthy();
+    expect(_cnpj.validate(cnpj)).toBeTruthy();
+  });
+
+  test.each([
+    // Com máscara
+    '11.222.333/0001-81',
+    '73.797.980/0001-79',
+    '06.946.762/0001-61',
+    '96.051.576/0001-57',
+    '55.585.709/0001-98',
+    // inteiro
+    99360938000180,
+    23693443000100,
+    // string
+    '32432147000147',
+    '91951438000100',
+  ])('validate() - Números válidos', (cnpj) => {
+
+    expect(validate(cnpj)).toBeTruthy();
+  });
+
+  test.each([
+    '53.797.980/0001-79',
+    '36.946.762/0001-61',
+    '26.051.576/0001-57',
+    '85.585.709/0001-98',
+    '39360938000180',
+    '93693443000100',
+    '12432147000147',
+    '61951438000100',
+    '11111111111111',
+  ])('validate() - Números inválidos', (cnpj) => {
+    expect(validate(cnpj)).toBeFalsy();
+  });
+
+  test.each([
+    '53.797.980/0001-79',
+    '36.946.762/0001-61',
+    '26.051.576/0001-57',
+    '85.585.709/0001-98',
+    '39360938000180',
+    '93693443000100',
+    '12432147000147',
+    '61951438000100',
+    '11111111111111',
+  ])('validateOrFail() - Números inválidos', (cnpj) => {
+    expect(() => validateOrFail(cnpj)).toThrow();
+
+
+  });
+
+  test('Parâmetro não informado', () => {
+    expect(isCNPJ('')).toBeFalsy();
+    expect(validate('')).toBeFalsy();
+    expect(() => validateOrFail('')).toThrow();
+    expect(() => dv('')).toThrow();
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes sem máscara', () => {
+    const cnpj = fake();
+    expect(validate(cnpj)).toBeTruthy();
+    expect(cnpj).toHaveLength(14);
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes com máscara', () => {
+    const cnpj = fake(true);
+    expect(validate(cnpj)).toBeTruthy();
+    expect(cnpj).toHaveLength(18);
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes com máscara usando opções como objeto', () => {
+    const cnpj = fake({ withMask: true, alphanumeric: false });
+    expect(validate(cnpj)).toBeTruthy();
+    expect(cnpj).toHaveLength(18);
+    expect(cnpj).toMatch(/^\d{2}\.\d{3}\.\d{3}\/\d{4}\-\d{2}$/);
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes sem máscara usando opções como objeto', () => {
+    const cnpj = fake({ withMask: false, alphanumeric: false });
+    expect(cnpj).toMatch(/^\d{14}$/);
+    expect(validate(cnpj)).toBeTruthy();
+    expect(cnpj).toHaveLength(14);
+  });
+
+  test.each([...Array(5)])('fake() - Gera CNPJs alfanuméricos', () => {
+    const cnpj = fake({ withMask: false, alphanumeric: true });
+    expect(cnpj).toMatch(/^[0-9A-Z]{14}$/);
+    expect(validate(cnpj)).toBeTruthy();
+    expect(cnpj).toHaveLength(14);
+  });
+
+  test.each([
+    { num: '112223330001', expected: '81' },
+    { num: 993609380001, expected: '80' },
+    { num: '324321470001', expected: '47' },
+    { num: '132496630001', expected: '96' },
+    { num: '752827070001', expected: '37' },
+    { num: '265066480001', expected: '28' },
+    { num: '708032680001', expected: '47' },
+    { num: '195255840001', expected: '47' },
+    { num: '888634370001', expected: '08' },
+    { num: '060757490001', expected: '84' },
+    { num: '554120850001', expected: '07' },
+    { num: '754097240001', expected: '92' },
+
+  ])('dv() - Verificando se o DV gerado está correto', (item) => {
+    const calcDv = dv(item.num);
+    expect(calcDv).toBe(item.expected);
+    expect(typeof calcDv).toBe('string');
+  });
+
+  test.each([
+    { value: '11222333000181', expected: '11.222.333/0001-81' },
+    { value: 99360938000180, expected: '99.360.938/0001-80' },
+    { value: '32432147000147', expected: '32.432.147/0001-47' },
+    { value: 432147000147, expected: '00.432.147/0001-47' },
+  ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {
+    const masked = mask(item.value);
+    expect(masked).toBe(item.expected);
+    expect(masked).toHaveLength(18);
+  });
+
+  test.each([
+    { value: '11.222.333/0001-81', expected: '11222333000181' },
+    { value: '73.797.980/0001-79', expected: '73797980000179' },
+    { value: '06.946.762/0001-61', expected: '06946762000161' },
+    { value: '96.051.576/0001-57', expected: '96051576000157' },
+    { value: '55.585.709/0001-98', expected: '55585709000198' },
+  ])('normalize() - Deve remover a máscara corretamente', (item) => {
+    const normalized = normalize(item.value);
+    expect(normalized).toBe(item.expected);
+    expect(normalized).toHaveLength(14);
+  });
+
+});
+
+describe('CNPJ alfanumérico', () => {
+
+  test.each([
+    'A3.170.7X3/0001-36',
+    'A31707X3000136',
+  ])('isValid() - checa se o cnpj alfanumérico %s é válido', (cnpj) => {
+    expect(validate(cnpj)).toBeTruthy();
+  });
+
+
+  test.each([
+    { num: 'A1.222.333/0001', expected: '50' },
+    { num: 'B1.222.333/0001', expected: '03' },
+    { num: 'C1.222.333/0001', expected: '67' },
+    { num: 'D12223330001', expected: '10' },
+    { num: 'E12223330001', expected: '74' },
+  ])('dv() - Verificando se o DV gerado de %s está correto', (item) => {
+    const calcDv = dv(item.num);
+    expect(calcDv).toBe(item.expected);
+    expect(typeof calcDv).toBe('string');
+  });
+
+
+});

package/test/cpf.test.ts

@@ -0,0 +1,124 @@
+import isCPF, { dv, fake, mask, validate, validateOrFail, normalize } from '../src/cpf';
+import * as _cpf from '../src/cpf';
+
+describe('CPF', () => {
+  test.each([
+    // masked
+    '133.782.710-00',
+    '400.448.260-79',
+    // integer
+    8796742020, // começa com zero
+    74172316085,
+    // string
+    '15886489070',
+    '90889477086',
+  ])('isCPF() - Números válidos', (item) => {
+
+    expect(isCPF(item)).toBeTruthy();
+    expect(_cpf.validate(item)).toBeTruthy();
+
+  });
+
+  test.each([
+    // masked
+    '133.782.710-00',
+    '400.448.260-79',
+    // integer
+    8796742020, // começa com zero
+    74172316085,
+    // string
+    '15886489070',
+    '90889477086',
+  ])('validate() - Números válidos', (item) => {
+    expect(validate(item)).toBeTruthy();
+  });
+
+  test.each([
+    '287.967.420-20',
+    '333.782.710-00',
+    '200.448.260-79',
+    '24172316085',
+    '25886489070',
+    '20889477086',
+    '11111111111',
+  ])('validate() - Números inválidos', (item) => {
+    expect(validate(item)).toBeFalsy();
+  });
+
+  test.each([
+    '287.967.420-20',
+    '333.782.710-00',
+    '200.448.260-79',
+    '24172316085',
+    '25886489070',
+    '20889477086',
+    '11111111111',
+  ])('validateOrFail() - Números inválidos', (item) => {
+    expect(() => validateOrFail(item)).toThrow();
+  });
+
+  test.each([
+    '24172316085000000',
+    '25886489070999999',
+    '20889477086888888',
+    '11111111111777777',
+  ])('validate() - Números válidos com caracteres adicionais', (item) => {
+    expect(validate(item)).toBeFalsy();
+  });
+
+  test('Parâmetro não informado', () => {
+    expect(isCPF('')).toBeFalsy();
+    expect(validate('')).toBeFalsy();
+    expect(() => validateOrFail('')).toThrow();
+    expect(() => dv('')).toThrow();
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes sem máscara', () => {
+    const cpf = fake();
+    expect(validate(cpf)).toBeTruthy();
+    expect(cpf).toHaveLength(11);
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes com máscara', () => {
+    const cpf = fake(true);
+    expect(validate(cpf)).toBeTruthy();
+    expect(cpf).toHaveLength(14);
+  });
+
+  test.each([
+    { num: '741723160', expected: '85' },
+    { num: 158864890, expected: '70' },
+    { num: '908894770', expected: '86' },
+  ])('dv() - Verificando se o DV gerado está correto', (item) => {
+    const calcDv = dv(item.num);
+    expect(calcDv).toBe(item.expected);
+    expect(typeof calcDv).toBe('string');
+  });
+
+  test.each([
+    { num: '74172316085', expected: '741.723.160-85' },
+    { num: 15886489070, expected: '158.864.890-70' },
+    { num: '90889477086', expected: '908.894.770-86' },
+    { num: 889477086, expected: '008.894.770-86' },
+  ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {
+    const masked = mask(item.num);
+    expect(masked).toBe(item.expected);
+    expect(masked).toHaveLength(14);
+  });
+
+  test.each([
+    { value: '741.723.160-85', expected: '74172316085' },
+    { value: '158.864.890-70', expected: '15886489070' },
+    { value: '908.894.770-86', expected: '90889477086' },
+    { value: '008.894.770-86', expected: '00889477086' },
+    { value: '74172316085', expected: '74172316085' },
+    { value: '15886489070', expected: '15886489070' },
+    { value: '90889477086', expected: '90889477086' },
+    { value: '889477086', expected: '00889477086' },
+  ])('normalize() - Testando se remove a máscara corretamente', (item) => {
+    const masked = normalize(item.value);
+
+    expect(masked).toBe(item.expected);
+    expect(masked).toHaveLength(11);
+  });
+});

package/test/index.test.ts

@@ -0,0 +1,85 @@
+import ValidateBR, {
+  isCNH,
+  isCNPJ,
+  isCPF,
+  isJudicialProcess,
+  isNUP17,
+  isPIS,
+  isPostalCode,
+  isRenavam,
+  isTituloEleitor,
+} from '../src/index';
+
+describe('ValidateBR', () => {
+  test('Deve importar isCNH', () => {
+    expect(ValidateBR.isCNH).toBeDefined();
+    expect(isCNH).toBeDefined();
+
+    expect(ValidateBR.isCNH('69044271146')).toBeTruthy();
+    expect(isCNH('69044271146')).toBeTruthy();
+  });
+
+  test('Deve importar isCNPJ', () => {
+    expect(ValidateBR.isCNPJ).toBeDefined();
+    expect(isCNPJ).toBeDefined();
+
+    expect(ValidateBR.isCNPJ('32432147000147')).toBeTruthy();
+    expect(isCNPJ('32432147000147')).toBeTruthy();
+  });
+
+  test('Deve importar isCPF', () => {
+    expect(ValidateBR.isCPF).toBeDefined();
+    expect(isCPF).toBeDefined();
+
+    expect(ValidateBR.isCPF('15886489070')).toBeTruthy();
+    expect(isCPF('15886489070')).toBeTruthy();
+  });
+
+  test('Deve importar isJudicialProcess', () => {
+    expect(ValidateBR.isJudicialProcess).toBeDefined();
+    expect(isJudicialProcess).toBeDefined();
+
+    expect(ValidateBR.isJudicialProcess('08002732820164058400')).toBeTruthy();
+    expect(isJudicialProcess('08002732820164058400')).toBeTruthy();
+  });
+
+  test('Deve importar isNUP17', () => {
+    expect(ValidateBR.isNUP17).toBeDefined();
+    expect(isNUP17).toBeDefined();
+
+    expect(ValidateBR.isNUP17('23037001462202165')).toBeTruthy();
+    expect(isNUP17('23037001462202165')).toBeTruthy();
+  });
+
+  test('Deve importar isPIS', () => {
+    expect(ValidateBR.isPIS).toBeDefined();
+    expect(isPIS).toBeDefined();
+
+    expect(ValidateBR.isPIS('23795126955')).toBeTruthy();
+    expect(isPIS('23795126955')).toBeTruthy();
+  });
+
+  test('Deve importar isPostalCode', () => {
+    expect(ValidateBR.isPostalCode).toBeDefined();
+    expect(isPostalCode).toBeDefined();
+
+    expect(ValidateBR.isPostalCode('PN718252423BR')).toBeTruthy();
+    expect(isPostalCode('PN718252423BR')).toBeTruthy();
+  });
+
+  test('Deve importar isRenavam', () => {
+    expect(ValidateBR.isRenavam).toBeDefined();
+    expect(isRenavam).toBeDefined();
+
+    expect(ValidateBR.isRenavam('80499688374')).toBeTruthy();
+    expect(isRenavam('80499688374')).toBeTruthy();
+  });
+
+  test('Deve importar isTituloEleitor', () => {
+    expect(ValidateBR.isTituloEleitor).toBeDefined();
+    expect(isTituloEleitor).toBeDefined();
+
+    expect(ValidateBR.isTituloEleitor('153036161686')).toBeTruthy();
+    expect(isTituloEleitor('153036161686')).toBeTruthy();
+  });
+});