@gipisistemas/ngx-core 1.0.26 → 1.0.28

package/components/confirm-dialog/confirm-dialog.scss

@@ -41,7 +41,9 @@
 
     .g-confirm-dialog-content {
         display: flex !important;
+        flex-direction: column !important;
         align-items: flex-start !important;
+        gap: 1.6rem !important;
         padding: 0 2rem !important;
         color: $secondary-900 !important;
         font-family: $font-family !important;
@@ -50,6 +52,14 @@
         min-height: 8rem !important;
         max-height: 30rem !important;
         overflow-y: auto !important;
+
+        .g-confirm-dialog-list-message {
+            padding-left: 1.6rem !important;
+
+            > li {
+                line-height: 2.4 !important;
+            }
+        }
     }
 
     .g-confirm-dialog-actions {

package/fesm2022/gipisistemas-ngx-core.mjs

@@ -704,7 +704,8 @@ class StringUtil {
         }
     }
     /**
-     * Trunca uma string para um tamanho máximo especificado e adiciona um sufixo (por padrão, '...') caso o limite seja ultrapassado.
+     * Trunca uma string para um tamanho máximo especificado e adiciona um sufixo (por padrão, '...')
+     * caso o limite seja ultrapassado.
      *
      * @param inp A string que será truncada.
      * @param maxLength O tamanho máximo da string antes do truncamento. (padrão é 50)
@@ -1829,7 +1830,8 @@ class CurrencyUtil {
      * @param inp Número a ser formatado.
      * @param options Configurações de formatação:
      *   - `digitsInfo` (opcional): Define o formato dos dígitos, como `1.2-2` (mínimo 1 inteiro, 2 casas decimais).
-     *   - `isPercent` (opcional): Se `true`, formata como porcentagem (ex: `0.5` → `50%`); caso contrário, como moeda (`R$`).
+     *   - `isPercent` (opcional): Se `true`, formata como porcentagem (ex: `0.5` → `50%`); caso contrário,
+     * como moeda (`R$`).
      *
      * @returns Uma string com o número formatado como moeda ou porcentagem.
      */
@@ -2167,17 +2169,25 @@ class DocumentUtil {
         return index === input.length - 1;
     }
     /**
-     * Verifica se um valor é considerado vazio.
-     * @param inp O valor a ser verificado.
-     * @returns O valor sem formatação.
+     * Remove caracteres de formatação de um CPF/CNPJ.
+     *
+     * Caso o valor contenha letras, mantém apenas caracteres alfanuméricos.
+     * Caso contrário, mantém apenas números.
+     *
+     * @param value O valor que terá a formatação removida.
+     * @returns O valor sem caracteres de formatação.
+     *
      * @example
-     * DocumentUtil.isEmpty('123-123'); // Retorna `123123`.
+     * DocumentUtil.clearFormat('00.123.123/0001-12'); // Retorna: '00123123000112'
+     * DocumentUtil.clearFormat('XH.BYE.J7E/0001-67'); // Retorna: 'XHBYEJ7E000167'
      */
     static clearFormat(value) {
         if (StringUtil.isEmpty(value)) {
             return '';
         }
-        return value.replace(/\D/g, '');
+        return /[a-zA-Z]/.test(value)
+            ? value.replace(/[^a-zA-Z0-9]/g, '')
+            : value.replace(/\D/g, '');
     }
     /**
      * Formata um CPF.
@@ -2267,97 +2277,132 @@ class DocumentUtil {
         return true;
     }
     /**
-     * Formata um CNPJ.
-     * @param cnpj O CNPJ a ser formatado.
-     * @param pad Se `true`, o CNPJ será preenchido com zeros à esquerda.
-     * @returns O CNPJ formatado.
+     * Formata um CNPJ numérico ou alfanumérico.
+     *
+     * A função remove automaticamente caracteres de formatação antes de aplicar
+     * a máscara padrão de CNPJ: `00.000.000/0000-00`.
+     *
+     * Também suporta:
+     * - CNPJ alfanumérico;
+     * - preenchimento automático com zeros à esquerda (`pad`);
+     * - formatação parcial para utilização em campos de digitação (`allowPartial`).
+     *
+     * Quando `allowPartial` estiver ativado, a máscara será aplicada
+     * gradualmente conforme a quantidade de caracteres informados.
+     *
+     * Caso `allowPartial` esteja desativado, apenas valores com 14 caracteres
+     * serão formatados. Caso contrário, será retornada uma string vazia.
+     *
+     * @param cnpj O CNPJ que será formatado.
+     * @param options Opções de formatação.
+     * @param options.pad Define se o valor deve ser preenchido com zeros à esquerda até atingir 14 caracteres.
+     * @param options.allowPartial Define se a máscara parcial deve ser aplicada durante a digitação.
+     *
+     * @returns O CNPJ formatado ou uma string vazia caso o valor seja inválido.
+     *
      * @example
-     * DocumentUtil.formatCnpj('00123123000112'); // Retorna `00.123.123/0001-12`.
-     * DocumentUtil.formatCnpj('123123000112', true); // Retorna `00.123.123/0001-12`.
+     * DocumentUtil.formatCnpj('12345678000190'); // Retorna: '12.345.678/0001-90'
+     * DocumentUtil.formatCnpj('12ABC3450001XX'); // Retorna: '12.ABC.345/0001-XX'
+     * DocumentUtil.formatCnpj('1234567890', { pad: true }); // Retorna: '00.001.234/5678-90'
+     * DocumentUtil.formatCnpj('12ABC345', { allowPartial: true }); // Retorna: '12.ABC.345'
+     * DocumentUtil.formatCnpj('123'); // Retorna: ''
      */
-    static formatCnpj(cnpj, pad) {
-        let digits = NumberUtil.onlyNumbers(cnpj);
+    static formatCnpj(cnpj, options) {
+        const pad = options?.pad ?? false;
+        const allowPartial = options?.allowPartial ?? false;
+        let cleanCnpj = this.clearFormat(cnpj).toUpperCase();
         if (pad) {
-            digits = digits.padStart(14, '0');
+            cleanCnpj = cleanCnpj.padStart(14, '0');
         }
-        const DOT_INDEXES = [1, 4];
-        const SLASH_INDEXES = [7];
-        const HYPHEN_INDEXES = [11];
-        return digits
-            .slice(0, 14)
-            .split('')
-            .reduce((acc, digit, index) => {
-            const result = `${acc}${digit}`;
-            if (!this._isLastChar(index, digits)) {
-                if (DOT_INDEXES.includes(index))
-                    return `${result}.`;
-                if (SLASH_INDEXES.includes(index))
-                    return `${result}/`;
-                if (HYPHEN_INDEXES.includes(index))
-                    return `${result}-`;
+        cleanCnpj = cleanCnpj.slice(0, 14);
+        const size = cleanCnpj.length;
+        if (allowPartial) {
+            if (size <= 2) {
+                return cleanCnpj;
             }
-            return result;
-        }, '');
+            if (size <= 5) {
+                return `${cleanCnpj.slice(0, 2)}.${cleanCnpj.slice(2)}`;
+            }
+            if (size <= 8) {
+                return `${cleanCnpj.slice(0, 2)}.${cleanCnpj.slice(2, 5)}.${cleanCnpj.slice(5)}`;
+            }
+            if (size <= 12) {
+                return `${cleanCnpj.slice(0, 2)}.${cleanCnpj.slice(2, 5)}.${cleanCnpj.slice(5, 8)}/${cleanCnpj.slice(8)}`;
+            }
+        }
+        else if (size !== 14) {
+            return '';
+        }
+        return cleanCnpj.replace(/(.{2})(.{3})(.{3})(.{4})(.{1,2})/, '$1.$2.$3/$4-$5');
     }
     /**
-     * Verifica se um CNPJ é válido.
-     * @param cnpj O CNPJ a ser verificado.
-     * @returns `true` se o CNPJ for válido, caso contrário, `false`.
+     * Valida um CNPJ numérico ou alfanumérico.
+     *
+     * A função aceita CNPJ com ou sem máscara, remove os caracteres de formatação
+     * e valida o dígito verificador conforme a regra oficial baseada no valor ASCII
+     * do caractere subtraído de 48 (`charCodeAt(0) - 48`).
+     *
+     * Regras aplicadas:
+     * - aceita CNPJ numérico e alfanumérico;
+     * - aceita valores com máscara, como `12.345.678/0001-90`;
+     * - aceita letras minúsculas, convertendo internamente para maiúsculas;
+     * - exige exatamente 14 caracteres após a limpeza;
+     * - exige que os 2 últimos caracteres sejam dígitos verificadores numéricos;
+     * - rejeita sequências inválidas repetidas, como `00000000000000`, `11111111111111`, `AAAAAAAAAAAA00`, entre outras;
+     * - rejeita caracteres não permitidos.
+     *
+     * @param cnpj O CNPJ que será validado.
+     * @returns `true` se o CNPJ for válido, caso contrário `false`.
+     *
      * @example
-     * DocumentUtil.isValidCnpj('12.345.678/0001-09'); // Retorna `true`.
-     * DocumentUtil.isValidCnpj('12345678000109'); // Retorna `true`.
-     * DocumentUtil.isValidCnpj('1234567800010'); // Retorna `false`.
-     * DocumentUtil.isValidCnpj('123456780001090'); // Retorna `false`.
+     * DocumentUtil.isValidCnpj('12.345.678/0001-90'); // Retorna: true ou false conforme os dígitos verificadores.
+     * DocumentUtil.isValidCnpj('12ABC3450001XX'); // Retorna: false, pois os dois últimos caracteres devem ser números.
+     * DocumentUtil.isValidCnpj('AAAAAAAAAAAA00'); // Retorna: false.
      */
     static isValidCnpj(cnpj) {
         if (StringUtil.isEmpty(cnpj)) {
             return false;
         }
-        cnpj = NumberUtil.onlyNumbers(cnpj);
-        if (StringUtil.isEmpty(cnpj) ||
-            cnpj.length !== 14 ||
-            cnpj === '00000000000000' ||
-            cnpj === '11111111111111' ||
-            cnpj === '22222222222222' ||
-            cnpj === '33333333333333' ||
-            cnpj === '44444444444444' ||
-            cnpj === '55555555555555' ||
-            cnpj === '66666666666666' ||
-            cnpj === '77777777777777' ||
-            cnpj === '88888888888888' ||
-            cnpj === '99999999999999') {
+        if (/[^A-Z0-9./-]/i.test(cnpj)) {
             return false;
         }
-        let length = cnpj.length - 2;
-        let numbers = cnpj.substring(0, length);
-        const digits = cnpj.substring(length);
-        let sum = 0;
-        let pos = length - 7;
-        for (let i = length; i >= 1; i--) {
-            sum += +numbers.charAt(length - i) * pos--;
-            if (pos < 2) {
-                pos = 9;
-            }
+        const cleanCnpj = this.clearFormat(cnpj).toUpperCase();
+        if (!/^[A-Z0-9]{12}\d{2}$/.test(cleanCnpj)) {
+            return false;
         }
-        let resultado = sum % 11 < 2 ? 0 : 11 - (sum % 11);
-        if (resultado !== +digits.charAt(0)) {
+        if (/^([A-Z0-9])\1{13}$/.test(cleanCnpj)) {
             return false;
         }
-        length = length + 1;
-        numbers = cnpj.substring(0, length);
-        sum = 0;
-        pos = length - 7;
-        for (let i = length; i >= 1; i--) {
-            sum += +numbers.charAt(length - i) * pos--;
-            if (pos < 2) {
-                pos = 9;
-            }
+        if (/^([A-Z0-9])\1{11}\d{2}$/.test(cleanCnpj)) {
+            return false;
         }
-        resultado = sum % 11 < 2 ? 0 : 11 - (sum % 11);
-        if (resultado !== +digits.charAt(1)) {
+        let size = 12;
+        let numbers = cleanCnpj.substring(0, size);
+        const digits = cleanCnpj.substring(size);
+        let sum = 0;
+        let weight = 2;
+        for (let i = size - 1; i >= 0; i--) {
+            const charValue = numbers.charCodeAt(i) - 48;
+            sum += charValue * weight;
+            weight = weight === 9 ? 2 : weight + 1;
+        }
+        let remainder = sum % 11;
+        let result = remainder < 2 ? 0 : 11 - remainder;
+        if (result !== parseInt(digits.charAt(0), 10)) {
             return false;
         }
-        return true;
+        size = 13;
+        numbers = cleanCnpj.substring(0, size);
+        sum = 0;
+        weight = 2;
+        for (let i = size - 1; i >= 0; i--) {
+            const charValue = numbers.charCodeAt(i) - 48;
+            sum += charValue * weight;
+            weight = weight === 9 ? 2 : weight + 1;
+        }
+        remainder = sum % 11;
+        result = remainder < 2 ? 0 : 11 - remainder;
+        return result === parseInt(digits.charAt(1), 10);
     }
     /**
      * Formata um CEP.
@@ -4151,7 +4196,7 @@ class BaseCrudService extends BaseService {
      * deleteAll(['123e4567-e89b-12d3-a456-426614174000', '987e6543-e21b-12d3-a456-426614174001'])
      *    .subscribe(isDeleted => console.log(isDeleted));
      */
-    deleteAll(idList, version) {
+    deleteAll(idList, version = 'v2') {
         for (const uuid of idList) {
             if (!UUIDUtil.isValid(uuid)) {
                 return of(false);
@@ -5480,7 +5525,7 @@ class BaseListComponent extends BaseComponent {
             cancel: () => this.loading.set(false),
         });
     }
-    deleteAllRegister(idList, permission, fetchAgain = true, version) {
+    deleteAllRegister(idList, permission, fetchAgain = true, version = 'v2') {
         try {
             idList = this.handleEntityIdList(idList);
             if (ArrayUtil.isEmpty(idList)) {
@@ -23028,7 +23073,7 @@ class TreeTable {
         return this._data;
     }
     constructor() {
-        this.matPaginatorRef = viewChild.required(MatPaginator);
+        this.matPaginatorRef = viewChild(MatPaginator, ...(ngDevMode ? [{ debugName: "matPaginatorRef" }] : []));
         this.actionsRef = contentChild('actions', ...(ngDevMode ? [{ debugName: "actionsRef" }] : []));
         this.menuContextRef = contentChild('menuContext', ...(ngDevMode ? [{ debugName: "menuContextRef" }] : []));
         this._uniqueId = inject(_IdGenerator).getId('gipi-tree-table-');
@@ -23085,22 +23130,22 @@ class TreeTable {
         this.onPage = output();
     }
     ngOnInit() {
-        const matPaginatorRef = this.matPaginatorRef();
-        if (!ObjectUtil.isEmpty(matPaginatorRef)) {
-            matPaginatorRef.page
-                .pipe(takeUntilDestroyed(this._destroyRef))
-                .subscribe(() => this._emitPaginator());
-        }
+        this.matPaginatorRef()
+            ?.page.pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe(() => this._emitPaginator());
     }
     _emitPaginator() {
-        const pageEvent = {
-            pageIndex: this.matPaginatorRef().pageIndex,
-            previousPageIndex: this.matPaginatorRef().pageIndex - 1,
-            pageSize: this.matPaginatorRef().pageSize,
-            length: this.matPaginatorRef().length,
-            pageSizeOptions: this.matPaginatorRef().pageSizeOptions,
-        };
-        this.onPage.emit(pageEvent);
+        const paginator = this.matPaginatorRef();
+        if (!paginator) {
+            return;
+        }
+        this.onPage.emit({
+            pageIndex: paginator.pageIndex,
+            previousPageIndex: paginator.pageIndex - 1,
+            pageSize: paginator.pageSize,
+            length: paginator.length,
+            pageSizeOptions: paginator.pageSizeOptions,
+        });
     }
     _getNodeChildren(node) {
         const propertyChildren = this.propertyTree;