nx-lecom-helper 1.0.1 → 1.0.3

package/README.md

@@ -0,0 +1,31 @@
+# NxLecomHelper
+
+Biblioteca UMD simples com funcoes utilitarias para CPF e CNPJ.
+
+## Como usar
+
+No browser, as funcoes ficam disponiveis em `window.NxLecomHelper`.
+
+```js
+NxLecomHelper.mascaraCpf("12345678901"); // "123.456.789-01"
+NxLecomHelper.mascaraCnpj("12ABC34501DE35"); // "12.ABC.345/01DE-35"
+
+NxLecomHelper.validarCpf("123.456.789-01"); // true/false
+NxLecomHelper.validarCnpj("12.ABC.345/01DE-35"); // true/false
+```
+
+## Funcoes
+
+- `alertTest(message)`: mostra um alerta para checar se a lib carregou.
+- `mascaraCpf(valor)`: aplica mascara no CPF (aceita com ou sem pontuacao).
+- `mascaraCnpj(valor)`: aplica mascara no CNPJ (aceita alfanumerico).
+- `validarCpf(valor)`: valida CPF pelo modulo 11 (pontos e tracos sao opcionais).
+- `validarCnpj(valor)`: valida CNPJ (numerico ou alfanumerico) com DV numerico.
+
+## Regras de validacao
+
+- CPF: usa o calculo padrao de dois digitos verificadores (modulo 11).
+- CNPJ alfanumerico: usa 12 caracteres base + 2 DVs numericos.
+  - Mapeamento de valor: valor do caractere = ASCII - 48 (0-9 = 0-9, A-Z = 17-42).
+  - Pesos: 2 a 9 da direita para a esquerda, repetindo (padrao da Receita/Serpro).
+

package/dist/nxLecom-helper.umd.js

@@ -1,16 +1,143 @@
-(function (global) {
-  "use strict";
-
-  // Evita sobrescrever se já existir
-  if (global.LecomAlert) return;
-
-  function show(message) {
-    alert(message || "LecomAlert funcionando!");
-  }
-
-  // API global mínima
-  global.LecomAlert = Object.freeze({
-    show
-  });
-
-})(typeof window !== "undefined" ? window : this);
+(function (global) {
+  "use strict";
+
+  if (global.NxLecomHelper) return;
+
+  function alertTest(message) {
+    alert(message || "NxLecomHelper funcionando!");
+  }
+
+  function somenteDigitos(valor) {
+    return String(valor || "").replace(/\D+/g, "");
+  }
+
+  function somenteAlfanumericos(valor) {
+    return String(valor || "").replace(/[^0-9a-zA-Z]+/g, "").toUpperCase();
+  }
+
+  function valorCaractereCnpj(caractere) {
+    var codigo = caractere.charCodeAt(0);
+    if (codigo >= 48 && codigo <= 57) return codigo - 48;
+    if (codigo >= 65 && codigo <= 90) return codigo - 48;
+    return NaN;
+  }
+
+  function mascaraCpf(valor) {
+    var digitos = somenteDigitos(valor).slice(0, 11);
+    if (!digitos) return "";
+    if (digitos.length <= 3) return digitos;
+    if (digitos.length <= 6)
+      return digitos.slice(0, 3) + "." + digitos.slice(3);
+    if (digitos.length <= 9)
+      return (
+        digitos.slice(0, 3) +
+        "." +
+        digitos.slice(3, 6) +
+        "." +
+        digitos.slice(6)
+      );
+    return (
+      digitos.slice(0, 3) +
+      "." +
+      digitos.slice(3, 6) +
+      "." +
+      digitos.slice(6, 9) +
+      "-" +
+      digitos.slice(9)
+    );
+  }
+
+  function mascaraCnpj(valor) {
+    var caracteres = somenteAlfanumericos(valor).slice(0, 14);
+    if (!caracteres) return "";
+    if (caracteres.length <= 2) return caracteres;
+    if (caracteres.length <= 5)
+      return caracteres.slice(0, 2) + "." + caracteres.slice(2);
+    if (caracteres.length <= 8)
+      return (
+        caracteres.slice(0, 2) +
+        "." +
+        caracteres.slice(2, 5) +
+        "." +
+        caracteres.slice(5)
+      );
+    if (caracteres.length <= 12)
+      return (
+        caracteres.slice(0, 2) +
+        "." +
+        caracteres.slice(2, 5) +
+        "." +
+        caracteres.slice(5, 8) +
+        "/" +
+        caracteres.slice(8)
+      );
+    return (
+      caracteres.slice(0, 2) +
+      "." +
+      caracteres.slice(2, 5) +
+      "." +
+      caracteres.slice(5, 8) +
+      "/" +
+      caracteres.slice(8, 12) +
+      "-" +
+      caracteres.slice(12)
+    );
+  }
+
+  function validarCpf(valor) {
+    var cpf = somenteDigitos(valor);
+    if (cpf.length !== 11) return false;
+    if (/^(\d)\1{10}$/.test(cpf)) return false;
+
+    var soma = 0;
+    for (var i = 0; i < 9; i++) {
+      soma += parseInt(cpf.charAt(i), 10) * (10 - i);
+    }
+    var resto = (soma * 10) % 11;
+    if (resto === 10) resto = 0;
+    if (resto !== parseInt(cpf.charAt(9), 10)) return false;
+
+    soma = 0;
+    for (var j = 0; j < 10; j++) {
+      soma += parseInt(cpf.charAt(j), 10) * (11 - j);
+    }
+    resto = (soma * 10) % 11;
+    if (resto === 10) resto = 0;
+    return resto === parseInt(cpf.charAt(10), 10);
+  }
+
+  function validarCnpj(valor) {
+    var cnpj = somenteAlfanumericos(valor);
+    if (cnpj.length !== 14) return false;
+    if (/^([A-Z0-9])\1{13}$/.test(cnpj)) return false;
+    if (!/^\d{2}$/.test(cnpj.slice(12))) return false;
+
+    var pesos1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+    var pesos2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+    var soma = 0;
+    for (var i = 0; i < 12; i++) {
+      var valor = valorCaractereCnpj(cnpj.charAt(i));
+      if (isNaN(valor)) return false;
+      soma += valor * pesos1[i];
+    }
+    var resultado = soma % 11 < 2 ? 0 : 11 - (soma % 11);
+    if (resultado !== parseInt(cnpj.charAt(12), 10)) return false;
+
+    soma = 0;
+    for (var j = 0; j < 13; j++) {
+      var valor2 = valorCaractereCnpj(cnpj.charAt(j));
+      if (isNaN(valor2)) return false;
+      soma += valor2 * pesos2[j];
+    }
+    resultado = soma % 11 < 2 ? 0 : 11 - (soma % 11);
+    return resultado === parseInt(cnpj.charAt(13), 10);
+  }
+
+  global.NxLecomHelper = Object.freeze({
+    alertTest,
+    mascaraCpf,
+    mascaraCnpj,
+    validarCpf,
+    validarCnpj,
+  });
+})(typeof window !== "undefined" ? window : this);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx-lecom-helper",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Utilitários JS para BPM Lecom (API global)",
   "main": "dist/nxLecom-helper.umd.js",
   "files": [
@@ -11,5 +11,8 @@
   "author": {
     "name": "Thiago Costa",
     "email": "thiago.costa@nexum.com.br"
+  },
+  "dependencies": {
+    "nx-lecom-helper": "^1.0.1"
   }
-}
+}