@kigi/components 1.63.4-beta.1 → 1.63.6-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kigi/components",
-  "version": "1.63.4-beta.1",
+  "version": "1.63.6-beta.1",
   "description": "@kigi/components",
   "main": "src/components/index.ts",
   "scripts": {
@@ -32,6 +32,7 @@
     "@firebase/remote-config": "^0.1.25",
     "@firebase/storage": "^0.3.39",
     "@firebase/util": "^0.2.50",
+    "@kigi/components": "^1.63.2",
     "@syncfusion/ej2-base": "^17.4.43",
     "@syncfusion/ej2-buttons": "^17.4.43",
     "@syncfusion/ej2-documenteditor": "^17.4.43",
@@ -100,4 +101,4 @@
     "webpack": "^2.5.1",
     "webpack-dev-server": "^2.6.1"
   }
-}
+}

package/src/components/mbg-address/mbg-address.ts

@@ -317,7 +317,6 @@ class MbgAddressController {
       (this.address && this.address.uf && this.address.uf.initial)
 
     const uf = getStatesBR().filter((state) => state.initial === currentStateSignal)[0]
-
     return {
       EX: (this.ngModel.country || '').toLowerCase() !== 'brasil',
       country: this.ngModel.country || this.address.country,

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

@@ -2,6 +2,20 @@
      ng-if="$ctrl.props"
      mbg-autocomplete-off>
     <input type="text"
+           ng-if="$ctrl.allowAlphanumeric"
+           ng-model="$ctrl.ngModel"
+           ng-change="$ctrl.onChange()"
+           placeholder="{{ $ctrl.props.placeholder }}"
+           ng-required="$ctrl.ngRequired"
+           ng-disabled="$ctrl.ngDisabled"
+           ng-blur="$ctrl.ngBlur({ $event })"
+           ng-focus="$ctrl.ngFocus({ $event })"
+           ng-keyup="$ctrl.ngKeyup({ $event })"
+           ng-keypress="$ctrl.ngKeypress({ $event })"
+           ng-keydown="$ctrl.ngKeydown({ $event })"
+           mbg-alphanumeric-cnpj-mask />
+    <input type="text"
+           ng-if="!$ctrl.allowAlphanumeric"
            ng-model="$ctrl.ngModel"
            ng-change="$ctrl.onChange()"
            placeholder="{{ $ctrl.props.placeholder }}"

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

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

@@ -1,16 +1,32 @@
 <div class="mbg-input-wrapper mb-input-cpfcnpj-wrapper"
      ng-if="$ctrl.props"
      mbg-autocomplete-off>
-    <input type="text"
-           ng-model="$ctrl.ngModel"
-           ng-change="$ctrl.onChange()"
-           placeholder="{{ $ctrl.props.placeholder }}"
-           ng-required="$ctrl.ngRequired"
-           ng-disabled="$ctrl.ngDisabled"
-           ng-blur="$ctrl.ngBlur({ $event })"
-           ng-focus="$ctrl.ngFocus({ $event })"
-           ng-keyup="$ctrl.ngKeyup({ $event })"
-           ng-keypress="$ctrl.ngKeypress({ $event })"
-           ng-keydown="$ctrl.ngKeydown({ $event })"
-           ui-br-cpfcnpj-mask />
-</div>
+     <input type="text"
+            ng-if="$ctrl.allowAlphanumeric"
+            ng-model="$ctrl.ngModel"
+            name="{{$ctrl.name}}"
+            ng-change="$ctrl.onChange()"
+            placeholder="{{ $ctrl.props.placeholder }}"
+            ng-required="$ctrl.ngRequired"
+            ng-disabled="$ctrl.ngDisabled"
+            ng-blur="$ctrl.ngBlur({ $event })"
+            ng-focus="$ctrl.ngFocus({ $event })"
+            ng-keyup="$ctrl.ngKeyup({ $event })"
+            ng-keypress="$ctrl.ngKeypress({ $event })"
+            ng-keydown="$ctrl.ngKeydown({ $event })"
+            mbg-alphanumeric-cnpj-mask />
+     <input type="text"
+            ng-if="!$ctrl.allowAlphanumeric"
+            ng-model="$ctrl.ngModel"
+            name="{{$ctrl.name}}"
+            ng-change="$ctrl.onChange()"
+            placeholder="{{ $ctrl.props.placeholder }}"
+            ng-required="$ctrl.ngRequired"
+            ng-disabled="$ctrl.ngDisabled"
+            ng-blur="$ctrl.ngBlur({ $event })"
+            ng-focus="$ctrl.ngFocus({ $event })"
+            ng-keyup="$ctrl.ngKeyup({ $event })"
+            ng-keypress="$ctrl.ngKeypress({ $event })"
+            ng-keydown="$ctrl.ngKeydown({ $event })"
+            ui-br-cpfcnpj-mask />
+</div>

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

@@ -1,99 +1,100 @@
 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'
+
+// ---------------------------------------------------------------------------
+// Directive: mbg-document-mask-directive
+// (lógica movida para o helper, re-exportada via import acima)
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// Component: mbg-input-cpfcnpj
+// ---------------------------------------------------------------------------
 
 class MbgInputCpfCnpjController {
-    private ngChange
-    private ngModel
-    private ngRequired
-    private ngDisabled
-    private props
-    public valid
+  private ngChange
+  private ngModel
+  private ngRequired
+  private ngDisabled
+  private allowAlphanumeric: boolean
+  private name
+  private props
+  public valid
 
-    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 = 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)
-        } else {
-            return false
-        }
+    if ($attrs.ngDisabled === '') {
+      this.ngDisabled = true
     }
-
-    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
+    this.props = {
+      placeholder: $attrs.placeholder || '',
     }
+  }
 
-    validCpf(value) {
-        let digits = value.substr(0, 9)
-        let firstCalc = this.CalcDigits(digits)
-        let newCpf = this.CalcDigits(firstCalc, 11)
-        if (newCpf === value) {
-            return true
-        } else {
-            return false
-        }
-    }
+  $onInit() {
+    this.allowAlphanumeric = this.allowAlphanumeric === true
+  }
 
-    validCnpj(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
+  ngBlur(evt) {
+    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 {
+      this.valid = false
     }
+  }
 
-    onChange() {
-        if (this.ngChange) {
-            this.ngChange({})
-        }
+  CalcDigits(digits, positions = 10, sumDigits = 0) {
+    digits = digits.toString()
+    for (let i = 0; i < digits.length; i++) {
+      sumDigits += digits[i] * positions
+      positions--
+      if (positions < 2) positions = 9
     }
+    sumDigits = sumDigits % 11
+    if (sumDigits < 2) sumDigits = 0
+    else sumDigits = 11 - sumDigits
+    return digits + sumDigits
+  }
+
+  validCpf(value) {
+    const digits = value.substr(0, 9)
+    const firstCalc = this.CalcDigits(digits)
+    const newCpf = this.CalcDigits(firstCalc, 11)
+    return newCpf === value
+  }
+
+  onChange() {
+    if (this.ngChange) this.ngChange({})
+  }
 }
 MbgInputCpfCnpjController.$inject = ['$scope', '$element', '$attrs']
 
 const mbgInputCpfCnpj = {
-    bindings: {
-        ngModel: '=',
-        ngChange: '&?',
-        ngRequired: '=?',
-        ngDisabled: '=?',
-        ngBlur: '&?',
-        ngFocus: '&?',
-        ngKeyup: '&?',
-        ngKeypress: '&?',
-        ngKeydown: '&?',
-    },
-    template,
-    controller: MbgInputCpfCnpjController,
+  bindings: {
+    ngModel: '=',
+    ngChange: '&?',
+    ngRequired: '=?',
+    ngDisabled: '=?',
+    ngBlur: '&?',
+    ngFocus: '&?',
+    ngKeyup: '&?',
+    ngKeypress: '&?',
+    ngKeydown: '&?',
+    allowAlphanumeric: '<?',
+    name: '@?',
+  },
+  template,
+  controller: MbgInputCpfCnpjController,
 }
 
-export { mbgInputCpfCnpj }
+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/ie-directive/ie-directive.ts

@@ -26,7 +26,6 @@ export class NgMaskIe {
     scope.$watch(attrs.ngModel, (data) => {
       const state = getState()
       const valid = this.validate(data, state)
-      console.log('[mbg-mask-ie] watch — data:', data, '| state:', state, '| valid:', valid)
 
       ngModelController.$setValidity('ie', !!valid)
 
@@ -82,7 +81,6 @@ export class NgMaskIe {
   }
 
   validate(ngModel, state) {
-    console.log('[mbg-mask-ie] validate — ngModel:', ngModel, '| state:', state)
     switch (state) {
       case 'TO':
         return this.validateTO(ngModel)
@@ -214,26 +212,20 @@ export class NgMaskIe {
   }
 
   validateRS(ie) {
-    console.log('[validateRS] ie recebido:', ie)
     const digits = (ie || '').replace(/\D/g, '')
-    console.log('[validateRS] digits (só números):', digits, '| length:', digits.length)
     const padded = digits.length === 9 ? '0' + digits : digits
-    console.log('[validateRS] padded:', padded, '| length:', padded.length)
     if (padded.length !== 10) {
-      console.log('[validateRS] INVÁLIDO — length esperado 10, recebido:', padded.length)
       return false
     }
     const weights = [2, 9, 8, 7, 6, 5, 4, 3, 2]
     let sum = 0
     for (let i = 0; i < weights.length; i++) {
       const partial = parseInt(padded[i]) * weights[i]
-      console.log(`[validateRS] i=${i} dígito=${padded[i]} peso=${weights[i]} parcial=${partial}`)
       sum += partial
     }
     const remainder = sum % 11
     const dv = remainder < 2 ? 0 : 11 - remainder
     const dvIe = parseInt(padded[9])
-    console.log('[validateRS] soma:', sum, '| resto:', remainder, '| dv calculado:', dv, '| dv do IE:', dvIe, '| VÁLIDO:', dv === dvIe)
     return dv === dvIe
   }
 

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 './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()