@kigi/components 1.62.7-beta.1 → 1.62.9-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kigi/components",
-  "version": "1.62.7-beta.1",
+  "version": "1.62.9-beta.1",
   "description": "@kigi/components",
   "main": "src/components/index.ts",
   "scripts": {

package/src/components/mbg-input-cnpj/mbg-input-cnpj.ts

@@ -1,82 +1,76 @@
 import './mbg-input-cnpj.scss'
 import template from './mbg-input-cnpj.html'
+import {
+  normalizeAlphanumericCnpj,
+  formatAlphanumericCnpj,
+  isValidAlphanumericCnpj,
+  mbgDocumentMaskDirective,
+} from '../../helpers/mbg-document-mask-directive'
+import { isValidCnpj } from '../../helpers/cnpj-validador'
 
 class MbgInputCnpjController {
-    private ngChange
-    private ngModel
-    private ngRequired
-    private ngDisabled
-    private props
-    public valid = true
+  private ngChange
+  private ngModel
+  private ngRequired
+  private ngDisabled
+  private props
+  private allowAlphanumeric: boolean
+  public valid = true
 
-    constructor(public $scope, public $element, public $attrs) {
-        if ($attrs.ngRequired === '') {
-            this.ngRequired = true
-        }
-        if ($attrs.ngDisabled === '') {
-            this.ngDisabled = true
-        }
-        this.props = {
-            placeholder: $attrs.placeholder || '',
-        }
+  constructor(
+    public $scope,
+    public $element,
+    public $attrs,
+  ) {
+    if ($attrs.ngRequired === '') {
+      this.ngRequired = true
     }
-
-    ngBlur(evt) {
-        this.valid = this.validaCnpj(evt.$event.target.value)
+    if ($attrs.ngDisabled === '') {
+      this.ngDisabled = true
     }
-
-    validaCnpj(value) {
-        let original = value
-        let firstNumbers = value.substr(0, 12)
-        let firstCalc = this.CalcDigits(firstNumbers, 5)
-        let secondCalc = this.CalcDigits(firstCalc, 6)
-        if (secondCalc === original) {
-            return true
-        }
-        return false
+    this.props = {
+      placeholder: $attrs.placeholder || '',
     }
+  }
+
+  $onInit() {
+    this.allowAlphanumeric = this.allowAlphanumeric === true
+  }
+
+  ngBlur(evt) {
+    const raw = evt.$event.target.value
+    const clean = normalizeAlphanumericCnpj(raw)
 
-    CalcDigits(digits, positions = 10, sumDigits = 0) {
-        digits = digits.toString()
-        for (let i = 0; i < digits.length; i++) {
-            sumDigits = sumDigits + (digits[i] * positions)
-            positions--
-            if (positions < 2) {
-                positions = 9
-            }
-        }
-        sumDigits = sumDigits % 11
-        if (sumDigits < 2) {
-            sumDigits = 0
-        } else {
-            sumDigits = 11 - sumDigits
-        }
-        let cnpj = digits + sumDigits
-        return cnpj
+    if (clean.length === 14) {
+      this.valid = isValidAlphanumericCnpj(clean)
+    } else {
+      this.valid = isValidCnpj(clean)
     }
+  }
 
-    onChange() {
-        if (this.ngChange) {
-            this.ngChange({})
-        }
+  onChange() {
+    if (this.ngChange) {
+      this.ngChange({})
     }
+  }
 }
 MbgInputCnpjController.$inject = ['$scope', '$element', '$attrs']
 
 const mbgInputCnpj = {
-    bindings: {
-        ngModel: '=',
-        ngChange: '&?',
-        ngRequired: '=?',
-        ngDisabled: '=?',
-        ngBlur: '&?',
-        ngFocus: '&?',
-        ngKeyup: '&?',
-        ngKeypress: '&?',
-        ngKeydown: '&?',
-    },
-    template,
-    controller: MbgInputCnpjController,
+  bindings: {
+    ngModel: '=',
+    ngChange: '&?',
+    ngRequired: '=?',
+    ngDisabled: '=?',
+    ngBlur: '&?',
+    ngFocus: '&?',
+    ngKeyup: '&?',
+    ngKeypress: '&?',
+    ngKeydown: '&?',
+    allowAlphanumeric: '<?',
+  },
+  template,
+  controller: MbgInputCnpjController,
 }
 
-export { mbgInputCnpj }
+export { mbgInputCnpj, mbgDocumentMaskDirective }

package/src/components/mbg-input-cpfcnpj/index.ts

@@ -1,10 +1,10 @@
 import * as angular from 'angular'
-import { mbgInputCpfCnpj, mbgAlphanumericCnpjMask } from './mbg-input-cpfcnpj'
+import { mbgInputCpfCnpj, mbgDocumentMaskDirective } from './mbg-input-cpfcnpj'
 
 const mbgInputCpfCnpjModule = angular
     .module('mbg.components.mbgInputCpfCnpj', [])
     .component('mbgInputCpfCnpj', mbgInputCpfCnpj)
-    .directive('mbgAlphanumericCnpjMask', mbgAlphanumericCnpjMask)
+    .directive('mbgAlphanumericCnpjMask', mbgDocumentMaskDirective)
     .name
 
 export { mbgInputCpfCnpjModule }

package/src/components/mbg-input-cpfcnpj/mbg-input-cpfcnpj.ts

@@ -1,210 +1,13 @@
 import './mbg-input-cpfcnpj.scss'
 import template from './mbg-input-cpfcnpj.html'
+import { mbgDocumentMaskDirective } from '../../helpers/mbg-document-mask-directive'
+import { isValidCnpj } from '../../helpers/cnpj-validador'
 
 // ---------------------------------------------------------------------------
-// Mask formatting helpers
+// Directive: mbg-document-mask-directive
+// (lógica movida para o helper, re-exportada via import acima)
 // ---------------------------------------------------------------------------
 
-const CPF_MASK = '###.###.###-##'
-const CNPJ_MASK = '##.###.###/####-##'
-
-function cleanValue(value: string): string {
-  return (value || '').replace(/[^A-Za-z0-9]/g, '').toUpperCase()
-}
-
-function hasLetters(value: string): boolean {
-  return /[A-Za-z]/.test(value)
-}
-
-function formatCpf(clean: string): string {
-  const digits = clean.replace(/[^0-9]/g, '').substring(0, 11)
-  const result: string[] = []
-  let digitIdx = 0
-
-  for (let i = 0; i < CPF_MASK.length && digitIdx < digits.length; i++) {
-    if (CPF_MASK[i] === '#') {
-      result.push(digits[digitIdx])
-      digitIdx++
-    } else {
-      result.push(CPF_MASK[i])
-    }
-  }
-
-  return result.join('')
-}
-
-function formatCnpj(clean: string): string {
-  const safe = clean.substring(0, 14)
-  const result: string[] = []
-  let cleanIndex = 0
-
-  for (let i = 0; i < CNPJ_MASK.length && cleanIndex < safe.length; i++) {
-    const maskChar = CNPJ_MASK[i]
-
-    if (maskChar === '#') {
-      const char = safe[cleanIndex]
-      const isCheckDigitPosition = cleanIndex >= 12
-
-      if (isCheckDigitPosition) {
-        if (/[0-9]/.test(char)) {
-          result.push(char)
-        }
-        cleanIndex++
-      } else {
-        if (/[A-Z0-9]/.test(char)) {
-          result.push(char)
-        }
-        cleanIndex++
-      }
-    } else {
-      result.push(maskChar)
-    }
-  }
-
-  return result.join('')
-}
-
-function smartFormat(value: string): string {
-  const clean = normalizeForModel(value)
-  if (clean.length === 0) return ''
-  if (hasLetters(clean)) return formatCnpj(clean)
-  if (clean.length <= 11) return formatCpf(clean)
-  return formatCnpj(clean)
-}
-
-function normalizeForModel(value: string): string {
-  const clean = cleanValue(value)
-  if (!clean) return ''
-  if (hasLetters(clean)) return clean.substring(0, 14)
-  if (clean.length <= 11) return clean
-  return clean.substring(0, 14)
-}
-
-function isRepeatedNumeric(value: string): boolean {
-  return /^(\d)\1+$/.test(value)
-}
-
-function getDigitValue(char: string): number {
-  return char.charCodeAt(0) - 48
-}
-
-function calculateCpfDigit(base: string, startWeight: number): number {
-  let sum = 0
-
-  for (let i = 0; i < base.length; i++) {
-    sum += Number(base[i]) * (startWeight - i)
-  }
-
-  const remainder = sum % 11
-  return remainder < 2 ? 0 : 11 - remainder
-}
-
-function isValidCpf(value: string): boolean {
-  if (!/^\d{11}$/.test(value) || isRepeatedNumeric(value)) return false
-
-  const firstDigit = calculateCpfDigit(value.slice(0, 9), 10)
-  const secondDigit = calculateCpfDigit(`${value.slice(0, 9)}${firstDigit}`, 11)
-  return value === `${value.slice(0, 9)}${firstDigit}${secondDigit}`
-}
-
-function calculateCnpjDigit(base: string, weights: number[]): number {
-  let sum = 0
-
-  for (let i = 0; i < base.length; i++) {
-    sum += getDigitValue(base[i]) * weights[i]
-  }
-
-  const remainder = sum % 11
-  return remainder < 2 ? 0 : 11 - remainder
-}
-
-function isValidCnpj(value: string): boolean {
-  if (!/^[A-Z0-9]{12}[0-9]{2}$/.test(value)) return false
-  if (/^\d{14}$/.test(value) && isRepeatedNumeric(value)) return false
-
-  const base = value.slice(0, 12)
-  const firstDigit = calculateCnpjDigit(base, [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2])
-  const secondDigit = calculateCnpjDigit(
-    `${base}${firstDigit}`,
-    [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2],
-  )
-
-  return value.slice(12) === `${firstDigit}${secondDigit}`
-}
-
-function isCpfCandidate(value: string): boolean {
-  return /^\d*$/.test(value) && value.length <= 11
-}
-
-function isCnpjCandidate(value: string): boolean {
-  return value.length > 11 || hasLetters(value)
-}
-
-function isDocumentValid(value: string): boolean {
-  if (!value) return true
-  if (isCpfCandidate(value)) {
-    if (value.length < 11) return true
-    return isValidCpf(value)
-  }
-  if (isCnpjCandidate(value)) {
-    if (value.length < 14) return true
-    if (value.length > 14) return false
-    return isValidCnpj(value)
-  }
-  return false
-}
-
-// ---------------------------------------------------------------------------
-// Directive: mbg-alphanumeric-cnpj-mask
-// ---------------------------------------------------------------------------
-
-class MbgAlphanumericCnpjMaskDirective {
-  static $inject = []
-
-  require = 'ngModel'
-  restrict = 'A'
-
-  link = (_scope, _element, _attrs, ngModel) => {
-    ngModel.$parsers.push((viewValue: string) => {
-      const clean = normalizeForModel(viewValue || '')
-      const formatted = smartFormat(clean)
-
-      if ((viewValue || '') !== formatted) {
-        ngModel.$setViewValue(formatted)
-        ngModel.$render()
-      }
-
-      return clean
-    })
-
-    ngModel.$formatters.push((modelValue: string) => {
-      return smartFormat(modelValue || '')
-    })
-
-    ngModel.$validators.cpf = (modelValue: string) => {
-      const clean = normalizeForModel(modelValue || '')
-      if (!clean || !isCpfCandidate(clean)) return true
-      if (clean.length < 11) return true
-      return isValidCpf(clean)
-    }
-
-    ngModel.$validators.cnpj = (modelValue: string) => {
-      const clean = normalizeForModel(modelValue || '')
-      if (!clean || !isCnpjCandidate(clean)) return true
-      if (clean.length < 14) return true
-      if (clean.length > 14) return false
-      return isValidCnpj(clean)
-    }
-
-    ngModel.$validators.cpfcnpj = (modelValue: string) => {
-      const clean = normalizeForModel(modelValue || '')
-      return isDocumentValid(clean)
-    }
-  }
-}
-
-const mbgAlphanumericCnpjMask = () => new MbgAlphanumericCnpjMaskDirective()
-
 // ---------------------------------------------------------------------------
 // Component: mbg-input-cpfcnpj
 // ---------------------------------------------------------------------------
@@ -240,16 +43,13 @@ class MbgInputCpfCnpjController {
   }
 
   ngBlur(evt) {
-    this.valid = evt.$event.target.value
-    this.valid = this.valid.toString()
-    this.valid = this.valid.replace(/[^0-9]/g, '')
-    if (this.valid.length === 11) {
-      this.validCpf(this.valid)
-    }
-    if (this.valid.length === 14) {
-      this.validCnpj(this.valid)
+    const raw = `${evt.$event.target.value || ''}`.replace(/[^A-Za-z0-9]/g, '').toUpperCase()
+    if (raw.length === 11) {
+      this.valid = this.validCpf(raw)
+    } else if (raw.length === 14) {
+      this.valid = isValidCnpj(raw)
     } else {
-      return false
+      this.valid = false
     }
   }
 
@@ -273,13 +73,6 @@ class MbgInputCpfCnpjController {
     return newCpf === value
   }
 
-  validCnpj(value) {
-    const firstNumbers = value.substr(0, 12)
-    const firstCalc = this.CalcDigits(firstNumbers, 5)
-    const secondCalc = this.CalcDigits(firstCalc, 6)
-    return secondCalc === value
-  }
-
   onChange() {
     if (this.ngChange) this.ngChange({})
   }
@@ -304,4 +97,4 @@ const mbgInputCpfCnpj = {
   controller: MbgInputCpfCnpjController,
 }
 
-export { mbgInputCpfCnpj, mbgAlphanumericCnpjMask }
+export { mbgInputCpfCnpj, mbgDocumentMaskDirective }

package/src/helpers/cnpj-validador.ts

@@ -0,0 +1,38 @@
+// Single source of truth for CNPJ normalization and validation.
+
+// Strips punctuation/spaces, uppercases letters, truncates to 14 chars.
+// Preserves letters — safe for both numeric and alphanumeric CNPJs.
+export function normalizeCnpj(value: string): string {
+  const clean = `${value || ''}`.replace(/[^A-Za-z0-9]/g, '').toUpperCase()
+  return clean.substring(0, 14)
+}
+
+const WEIGHTS_D1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
+const WEIGHTS_D2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
+
+function charToValue(char: string): number {
+  return char.charCodeAt(0) - 48
+}
+
+function calcDigit(base: string, weights: number[]): number {
+  let sum = 0
+  for (let i = 0; i < base.length; i++) {
+    sum += charToValue(base[i]) * weights[i]
+  }
+  const r = sum % 11
+  return r < 2 ? 0 : 11 - r
+}
+
+// Accepts raw or pre-normalized input (with or without punctuation/mask).
+// Validates numeric and alphanumeric CNPJs (Receita Federal 2026).
+export function isValidCnpj(value: string): boolean {
+  const cnpj = normalizeCnpj(value)
+
+  if (!/^[A-Z0-9]{12}[0-9]{2}$/.test(cnpj)) return false
+  if (/^\d{14}$/.test(cnpj) && /^(\d)\1+$/.test(cnpj)) return false
+
+  const base = cnpj.slice(0, 12)
+  const d1 = calcDigit(base, WEIGHTS_D1)
+  const d2 = calcDigit(`${base}${d1}`, WEIGHTS_D2)
+  return cnpj.slice(12) === `${d1}${d2}`
+}

package/src/helpers/mbg-document-mask-directive.ts

@@ -0,0 +1,160 @@
+// ---------------------------------------------------------------------------
+// Shared utilities: Alphanumeric CNPJ mask, formatting and validation
+// Used by: mbg-input-cpfcnpj, mbg-input-cnpj
+// ---------------------------------------------------------------------------
+
+import { isValidCnpj, normalizeCnpj } from '@kigi/components/src/helpers/cnpj-validador'
+export { isValidCnpj as isValidAlphanumericCnpj }
+export { normalizeCnpj as normalizeAlphanumericCnpj }
+
+const CNPJ_MASK = '##.###.###/####-##'
+const CPF_MASK = '###.###.###-##'
+
+export function hasLetters(value: string): boolean {
+  return /[A-Za-z]/.test(value)
+}
+
+export function formatCpf(clean: string): string {
+  const digits = clean.replace(/[^0-9]/g, '').substring(0, 11)
+  const result: string[] = []
+  let digitIdx = 0
+  for (let i = 0; i < CPF_MASK.length && digitIdx < digits.length; i++) {
+    if (CPF_MASK[i] === '#') result.push(digits[digitIdx++])
+    else result.push(CPF_MASK[i])
+  }
+  return result.join('')
+}
+
+function smartFormat(clean: string): string {
+  if (!clean) return ''
+  if (hasLetters(clean)) return formatAlphanumericCnpj(clean)
+  if (clean.length <= 11) return formatCpf(clean)
+  return formatAlphanumericCnpj(clean)
+}
+
+export function formatAlphanumericCnpj(clean: string): string {
+  const safe = clean.substring(0, 14)
+  const result: string[] = []
+  let cleanIndex = 0
+
+  for (let i = 0; i < CNPJ_MASK.length && cleanIndex < safe.length; i++) {
+    const maskChar = CNPJ_MASK[i]
+
+    if (maskChar === '#') {
+      const char = safe[cleanIndex]
+      const isCheckDigitPosition = cleanIndex >= 12
+
+      if (isCheckDigitPosition) {
+        if (/[0-9]/.test(char)) result.push(char)
+        cleanIndex++
+      } else {
+        if (/[A-Z0-9]/.test(char)) result.push(char)
+        cleanIndex++
+      }
+    } else {
+      result.push(maskChar)
+    }
+  }
+
+  return result.join('')
+}
+
+export function isCnpjCandidate(value: string): boolean {
+  return value.length > 11 || hasLetters(value)
+}
+
+export function isCpfCandidate(value: string): boolean {
+  return /^\d*$/.test(value) && value.length <= 11
+}
+
+function isRepeatedNumeric(value: string): boolean {
+  return /^(\d)\1+$/.test(value)
+}
+
+function calculateCpfDigit(base: string, startWeight: number): number {
+  let sum = 0
+  for (let i = 0; i < base.length; i++) {
+    sum += Number(base[i]) * (startWeight - i)
+  }
+  const remainder = sum % 11
+  return remainder < 2 ? 0 : 11 - remainder
+}
+
+export function isValidCpf(value: string): boolean {
+  if (!/^\d{11}$/.test(value) || isRepeatedNumeric(value)) return false
+  const firstDigit = calculateCpfDigit(value.slice(0, 9), 10)
+  const secondDigit = calculateCpfDigit(`${value.slice(0, 9)}${firstDigit}`, 11)
+  return value === `${value.slice(0, 9)}${firstDigit}${secondDigit}`
+}
+
+function isDocumentValid(value: string): boolean {
+  if (!value) return true
+  if (isCpfCandidate(value)) {
+    if (value.length < 11) return true
+    return isValidCpf(value)
+  }
+  if (isCnpjCandidate(value)) {
+    if (value.length < 14) {
+      if (hasLetters(value)) return false
+      return true
+    }
+    if (value.length > 14) return false
+    return isValidCnpj(value)
+  }
+  return false
+}
+
+// ---------------------------------------------------------------------------
+// AngularJS directive factory — reusable in any module
+// ---------------------------------------------------------------------------
+
+class MbgDocumentMaskDirective {
+  static $inject = []
+
+  require = 'ngModel'
+  restrict = 'A'
+
+  link = (_scope, _element, _attrs, ngModel) => {
+    ngModel.$parsers.push((viewValue: string) => {
+      const clean = normalizeCnpj(viewValue || '')
+      const formatted = smartFormat(clean)
+
+      if ((viewValue || '') !== formatted) {
+        ngModel.$setViewValue(formatted)
+        ngModel.$render()
+      }
+
+      return clean
+    })
+
+    ngModel.$formatters.push((modelValue: string) => {
+      return smartFormat(normalizeCnpj(modelValue || ''))
+    })
+
+    ngModel.$validators.cpf = (modelValue: string) => {
+      const clean = normalizeCnpj(modelValue || '')
+      if (!clean || !isCpfCandidate(clean)) return true
+      if (clean.length < 11) return true
+      return isValidCpf(clean)
+    }
+
+    ngModel.$validators.cnpj = (modelValue: string) => {
+      const clean = normalizeCnpj(modelValue || '')
+      if (!clean || !isCnpjCandidate(clean)) return true
+      if (clean.length < 14) {
+        if (hasLetters(clean)) return false
+        if (clean.length >= 12 && /[A-Z]/.test(clean.slice(12))) return false
+        return true
+      }
+      if (clean.length > 14) return false
+      return isValidCnpj(clean)
+    }
+
+    ngModel.$validators.cpfcnpj = (modelValue: string) => {
+      const clean = normalizeCnpj(modelValue || '')
+      return isDocumentValid(clean)
+    }
+  }
+}
+
+export const mbgDocumentMaskDirective = () => new MbgDocumentMaskDirective()