@kigi/components 1.62.6-beta.1 → 1.62.8-beta.1

package/package.json

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

package/src/components/mbg-connection-retry/mbg-connection-retry.ts

@@ -27,32 +27,11 @@ class MbgConnectionRetry {
 
     constructor(public $scope, public $element, public $attrs, public $timeout, public $http) { }
 
-    private isDebugEnabled = () => {
-        try {
-            return localStorage.getItem('mbgConnectionRetryDebug') === 'true'
-        } catch (error) {
-            return false
-        }
-    }
-
-    private debugLog = (message: string, payload?: any) => {
-        if (!this.isDebugEnabled()) { return }
-        if (payload !== undefined) {
-            console.log(`[mbg-connection-retry] ${message}`, payload)
-        } else {
-            console.log(`[mbg-connection-retry] ${message}`)
-        }
-    }
-
     $onInit() {
         this.verifingCount = 0
         this.onLine = navigator.onLine
         this.wifiImage = wifiImage
         this.connectionError = false
-        this.debugLog('$onInit', {
-            onLine: this.onLine,
-            pingUrl: this.pingUrl,
-        })
         window.addEventListener('online', this.handleConnectionChange)
         window.addEventListener('offline', this.handleConnectionChange)
         this.tryConnect()
@@ -65,11 +44,6 @@ class MbgConnectionRetry {
 
     handleConnectionChange = (evt) => {
         this.onLine = evt.type === 'online'
-        this.debugLog('handleConnectionChange', {
-            eventType: evt.type,
-            onLine: this.onLine,
-            navigatorOnLine: navigator.onLine,
-        })
         this.tryConnect()
     }
 
@@ -77,40 +51,22 @@ class MbgConnectionRetry {
         if (this.verifing) { return }
         this.verifing = true
         this.verifingCount++
-        this.debugLog('tryConnect:start', {
-            verifingCount: this.verifingCount,
-            onLine: this.onLine,
-            pingUrl: this.pingUrl,
-        })
         this.$timeout(() => {
             if (!this.pingUrl) { throw `O atributo ping-url não foi informado ou não possui valor.` }
             if (!this.onLine) {
                 this.verifingCount = 0
                 this.verifing = false
                 this.connectionError = true
-                this.debugLog('tryConnect:blocked_offline', {
-                    connectionError: this.connectionError,
-                    navigatorOnLine: navigator.onLine,
-                })
             } else {
                 return this.$http.get(this.pingUrl)
                     .then(() => {
                         this.verifing = false
                         this.verifingCount = 0
-                        this.debugLog('tryConnect:success', {
-                            connectionError: false,
-                        })
                         this.$timeout(() => this.connectionError = false)
                     })
-                    .catch((error) => {
+                    .catch(() => {
                         this.connectionError = true
                         this.verifing = false
-                        this.debugLog('tryConnect:error', {
-                            status: error && error.status,
-                            url: error && error.config && error.config.url,
-                            message: error && error.message,
-                            navigatorOnLine: navigator.onLine,
-                        })
                         this.$timeout(() => this.tryConnect(), 1500)
                     })
             }

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,103 @@
 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) {
+    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) {
+      isValidCnpj(this.valid)
+    } else {
+      return 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)
+}
+
+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,156 @@
+// ---------------------------------------------------------------------------
+// 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) 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 (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()