@sankhyalabs/core 0.0.0-bugfix-dev-KB-6165.0

package/src/utils/JSUtils.ts

@@ -0,0 +1,69 @@
+import { v4 as uuid } from "uuid"
+
+/**
+ * Classe com utiliários comuns para funções genéricas em JavaScript.
+ */
+export class JSUtils{
+
+  /**
+   * Método responsável em criar um timer para processar uma determinada função.
+   * 
+   * @param callback - Função de callback para processar após o timer.
+   * @param timeout - Valor dos milissegundos desejados para processar a função (o padrão é 300).
+   * 
+   * @returns - Retorna um método com controle de timer para processar a função de callback.
+   */
+  public static debounce(callback: any, timeout: number = 300): any {
+      let timer: any;
+      return (...args: any) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => { callback.apply(this, args); }, timeout);
+      };
+  }
+
+  /**
+   * Método responsável em validar se um elemento HTML está com o ellipsis ativo.
+   * 
+   * @param element - Elemento HTML que será verificado.
+   * 
+   * @returns - Retorna um valor booleando informando se o elemento está com o ellipsis ativo.
+   */
+  public static isEllipsisActive(element: HTMLElement | any): boolean {
+    if (element == undefined) {
+      return false;
+    }
+
+    if (element.clientWidth < element.scrollWidth) {
+        const style = element.currentStyle || window.getComputedStyle(element);
+        return style?.textOverflow === 'ellipsis';
+    }
+
+    return false;
+  }
+
+  /**
+   * Método que verifica se uma string está encodada com base64.
+   * 
+   * @param str - String que será verificada.
+   * 
+   * @returns - Retorna um valor booleando informando se a string está encodada com base64.
+   */
+  public static isBase64(str: string): boolean {
+    str = (str || '').replaceAll("\n", "");
+    if (str === '' || str.trim() === ''){ return false; }
+    try {
+        return window.btoa(window.atob(str)) == str;
+    } catch (err) {
+        return false;
+    }
+  }
+  
+  /**
+   * Método responsável em gerar um UUID.
+   * 
+   * @returns - Retorna um UUID.
+  */ 
+  public static generateUUID(): string {
+    return uuid();
+  }
+}

package/src/utils/MaskFormatter.ts

@@ -0,0 +1,407 @@
+/**
+ * `MaskFormatter` é usado para formatar strings. Seu comportamento
+ * é controlado pelo formato do atributo `mask` que especifica quais
+ * caracteres são válidos e onde devem estar posicionados, intercalando-os
+ * com eventuais caracteres literais expressados no padrão informado.
+ * Sua implementação é inspirada pela implementação em Java do [MaskFormatter](https://docs.oracle.com/javase/7/docs/api/javax/swing/text/MaskFormatter.html).
+ * 
+ * Para o padrão da máscara podem ser usados os seguintes caracteres especiais:
+ *
+ * | Caractere | Comportamento                                                                                               |
+ * |:---------:|-------------------------------------------------------------------------------------------------------------|
+ * | #         | Qualquer número                                                                                             |
+ * | '         | "Escapa" o caractere que vem na sequência. Útil quando desejamos converter um caractere especial em literal.|
+ * | U         | Qualquer letra. Transforma letras minúsculas em maiúsculas.                                                 |
+ * | L         | Qualquer letra. Transforma letras maiúsculas em minúsculas.                                                 |
+ * | A         | Qualquer letra ou número.                                                                                   |
+ * | ?         | Qualquer letra. Preserva maiúsculas e minúsculas.                                                           |
+ * | *         | Qualquer caractere.                                                                                         |
+ * 
+ * Os demais caracteres presentes no padrão serão tratados como literais, isto é,
+ * serão apenas inseridos naquela posição.
+ * 
+ * Quando o valor a ser formatado é menor que a máscara, um 'placeHolder'
+ * será inserido em cada posição ausente, completando a formatação.
+ * Por padrão será usado um espaço em branco como 'placeHolder', mas
+ * esse valor pode ser alterado.
+ * 
+ * Por exemplo:
+ * '''
+ *    const formatter: MaskFormatter = new MaskFormatter("###-####");
+ *    formatter.placeholder = '_';
+ *    console.log(formatter.format("123"));
+ * '''
+ * resultaria na string '123-____'.
+ * 
+ * ##Veja mais alguns exemplos:
+ * |Padrão          |Máscara           |Entrada       |Saída             |
+ * |----------------|------------------|--------------|------------------|
+ * |Telefone        |(##) ####-####    |3432192515    |(34) 3219-2515    |
+ * |CPF             |###.###.###-##    |12345678901   |123.456.789-01    |
+ * |CNPJ            |##.###.###/####-##|12345678901234|12.345.678/9012-34|
+ * |CEP             |##.###-###        |12345678      |12.345-678        |
+ * |PLACA (veículo) |UUU-####          |abc1234       |ABC-1234          |
+ * |Cor RGB         |'#AAAAAA          |00000F0       |#0000F0           |
+ *
+ */
+export class MaskFormatter {
+
+    private static DIGIT_KEY: string = "#";
+    private static LITERAL_KEY: string = "'";
+    private static UPPERCASE_KEY: string = "U";
+    private static LOWERCASE_KEY: string = "L";
+    private static ALPHA_NUMERIC_KEY: string = "A";
+    private static CHARACTER_KEY: string = "?";
+    private static ANYTHING_KEY: string = "*";
+
+    public static DEFAULT_MASKS: any = {
+        "cnpj": "##.###.###/####-##",
+        "cpf": "###.###.###-##",
+        "phone": "(##) ####-####",
+        "cep": "##.###-###"
+    };
+
+
+    private _mask: string = '';
+    private _maskChars: Array<MaskFormatter.MaskCharacter> = new Array<MaskFormatter.MaskCharacter>();
+
+    /**
+     * Determina qual caractere será usado dos caracteres não presentes no valor,
+     * ou seja, aqueles que o usuário ainda não informou. Por padrão usamos um espaço.
+     */
+    public placeholder: string = ' ';
+
+    /**
+     * Setter para mask. Trata-se do padrão que se espera ao formatar o texto.
+     */
+    public set mask(mask: string) {
+        this._mask = mask;
+        this.updateInternalMask();
+    }
+
+    /**
+     * Getter para mask.
+     *
+     * @return A última máscara informada.
+     */
+    public get mask(): string {
+        return this._mask;
+    }
+
+    constructor(mask: string) {
+        this.mask = mask;
+    }
+
+    /**
+     * Formata a string passada baseada na máscara definda pelo atributo mask.
+     *
+     * @param value Valor a ser formatado.
+     * @return O valor processado de acordo com o padrão.
+     */
+    public format(value: string): string {
+        let result: string = '';
+        const index: Array<number> = [0];
+
+        let counter: number = 0;
+        const maxCounter: number = this._maskChars.length;
+        while (counter < maxCounter) {
+            result = this._maskChars[counter].append(result, value, index);
+            counter++;
+        }
+
+        return result;
+    }
+
+    /**
+     * Prepara a formatação internamente de acordo com o padrão.
+     */
+    private updateInternalMask(): void {
+
+        this._maskChars.length = 0;
+
+        if (this.mask != null) {
+            let counter: number = 0;
+            const maxCounter: number = this.mask.length;
+            while (counter < maxCounter) {
+
+                let maskChar: string = this.mask.charAt(counter);
+
+                switch (maskChar) {
+                    case MaskFormatter.DIGIT_KEY:
+                        this._maskChars.push(new MaskFormatter.DigitMaskCharacter(this, maskChar));
+                        break;
+                    case MaskFormatter.LITERAL_KEY:
+                        if (++counter < maxCounter) {
+                            maskChar = this.mask.charAt(counter);
+                            this._maskChars.push(new MaskFormatter.LiteralCharacter(this, maskChar));
+                        }
+                        break;
+                    case MaskFormatter.UPPERCASE_KEY:
+                        this._maskChars.push(new MaskFormatter.UpperCaseCharacter(this, maskChar));
+                        break;
+                    case MaskFormatter.LOWERCASE_KEY:
+                        this._maskChars.push(new MaskFormatter.LowerCaseCharacter(this, maskChar));
+                        break;
+                    case MaskFormatter.ALPHA_NUMERIC_KEY:
+                        this._maskChars.push(new MaskFormatter.AlphaNumericCharacter(this, maskChar));
+                        break;
+                    case MaskFormatter.CHARACTER_KEY:
+                        this._maskChars.push(new MaskFormatter.CharCharacter(this, maskChar));
+                        break;
+                    case MaskFormatter.ANYTHING_KEY:
+                        this._maskChars.push(new MaskFormatter.MaskCharacter(this, maskChar));
+                        break;
+                    default:
+                        this._maskChars.push(new MaskFormatter.LiteralCharacter(this, maskChar));
+                        break;
+                }
+                counter++;
+            }
+        }
+    }
+
+    //
+    // Classes internas usadas para representar a máscara.
+    //
+    public static MaskCharacter = class {
+
+        public maskFormatter: MaskFormatter;
+        public type: string;
+
+        constructor(maskFormatter: MaskFormatter, type: string) {
+            this.maskFormatter = maskFormatter;
+            this.type = type;
+        }
+        /**
+         * Cada subclasse deve sobrescrever retornando true caso represente.
+         * um caractere literal. Por padrão o retorno é false.
+         */
+        public isLiteral(): boolean {
+            return false;
+        }
+
+        /**
+         * Retorna se é um texto válido.
+         * 
+         * @param aChar - Valor a ser validado.
+         * @returns - Retorna se é um texto válido.
+         */
+        public isValidCharacter(aChar: string): boolean {
+            if (this.isLiteral()) {
+                return (this.getChar(aChar) == aChar);
+            }
+
+            aChar = this.getChar(aChar);
+
+            return true;
+        }
+
+        /**
+         * Retorna o texto informado.
+         * 
+         * @param aChar - Texto a ser retornado.
+         * @returns - Texto informado.
+         */
+        public getChar(aChar: string): string {
+            return aChar;
+        }
+
+        /**
+         * Adiciona valor encontrado.
+         * 
+         * @param result - String a ser manipulada.
+         * @param formatting - String de formatação a ser adicionada na result.
+         * @param index - Índice que será utilizado para buscar no parâmetro formatting.
+         * 
+         * @returns - Valor passado na result incrementado com o valor encontrado na formatting.
+         * 
+         * @example
+         * ```  const result = "";
+         *       const formatting = "123456";
+         *       const index = [0];
+         *       const returnedResult = append(result, formatting, index);
+         *   ```
+         *   Retorna:
+         *   ```returnedResult = "1";
+         *      index = [1];
+         *   ```
+         */
+        public append(result: string, formatting: string, index: Array<number>): string {
+
+            const inString: boolean = index[0] < formatting.length;
+            const aChar: string = inString ? formatting.charAt(index[0]) : '';
+
+            if (this.isLiteral()) {
+                const literal: string = this.getChar(aChar);
+                result += literal;
+                if(literal === aChar){
+                   index[0] = index[0] + 1;
+                }
+            } else if (index[0] >= formatting.length) {
+                result += this.maskFormatter.placeholder;
+                index[0] = index[0] + 1;
+            } else if (this.isValidCharacter(aChar)) {
+                result += this.getChar(aChar);
+                index[0] = index[0] + 1;
+            } else {
+                throw new Error(`Valor inválido: "${aChar}". Na posição ${index[0] + 1} espera-se ${this.getFormatMessage()}.`);
+            }
+
+            return result;
+        }
+        
+        /**
+         * Obtém tipo por extenso.
+         * 
+         * @returns O tipo por extenso.
+         * @example
+         * Se o tipo for **ALPHA_NUMERIC_KEY** recebo **uma letra ou um número**
+         */   
+        public getFormatMessage(): string{
+            let message: string;
+            switch(this.type){
+                case MaskFormatter.UPPERCASE_KEY:
+                case MaskFormatter.LOWERCASE_KEY:
+                case MaskFormatter.CHARACTER_KEY:
+                    message = 'uma letra';
+                    break;
+                case MaskFormatter.DIGIT_KEY:
+                    message = 'um número';
+                    break;
+                case MaskFormatter.ALPHA_NUMERIC_KEY:
+                    message = 'uma letra ou um número';
+                    break;
+                default:
+                    message = ''
+            }
+            return message;
+        }
+    }
+
+    private static LiteralCharacter = class extends MaskFormatter.MaskCharacter {
+
+        private _fixedChar: string;
+
+        constructor(maskFormatter: MaskFormatter, fixedChar: string) {
+            super(maskFormatter, fixedChar);
+            this._fixedChar = fixedChar;
+        }
+
+        public isLiteral(): boolean {
+            return true;
+        }
+
+        public getChar(aChar: string): string {
+            aChar;
+            return this._fixedChar;
+        }
+    }
+
+    private static DigitMaskCharacter = class extends MaskFormatter.MaskCharacter {
+
+        /**
+         * Valida se o caracter é válido.
+         * 
+         * @param aChar - Caracter a ser validado.
+         * @returns - Se o caracter é valido ou não.
+         */  
+        public isValidCharacter(aChar: string): boolean {
+            return (this.isDigit(aChar) && super.isValidCharacter(aChar));
+        }
+
+        /**
+         * Valida se é um numéro.
+         * 
+         * @param char - String a ser verificada.
+         * @returns - Verdadeiro para caracteres numéricos.
+         * 
+         * @example
+         * ```Informado: "8" | Retorno: true ```
+         * @example
+         * ```Informado: "A" | Retorno: false ```
+         */  
+        private isDigit(char: string): boolean {
+            return char >= '0' && char <= '9'
+        }
+    }
+
+    
+    private static UpperCaseCharacter = class extends MaskFormatter.MaskCharacter {
+
+        /**
+        * Valida se a string é uma letra do alfabeto (a-z).
+        * 
+        * @param aChar - String passada para validação.
+        * @returns - Verdadeiro se a string passada for uma letra do alfabeto.
+        */ 
+        public isValidCharacter(aChar: string): boolean {
+            return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
+        }
+
+        /**
+        * Obtém a string passada em maiúscula.
+        * 
+        * @param aChar - String passada para validação.
+        * @returns - O caracter passado em letra maiúscula.
+        */ 
+        public getChar(aChar: string): string {
+            return aChar.toUpperCase();
+        }
+    }
+
+    private static LowerCaseCharacter = class extends MaskFormatter.MaskCharacter {
+
+        /**
+        * Valida se a string é uma letra do alfabeto (a-z).
+        * 
+        * @param aChar - String passada para validação.
+        * @returns - Verdadeiro se a string passada for uma letra do alfabeto.
+        */ 
+        public isValidCharacter(aChar: string): boolean {
+            return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
+        }
+
+        /**
+        * Obtém a string passada em minúscula.
+        * 
+        * @param aChar - String passada para validação.
+        * @returns - O caracter passado em letra minúscula.
+        */ 
+        public getChar(aChar: string): string {
+            return aChar.toLocaleLowerCase();
+        }
+    }
+
+    private static AlphaNumericCharacter = class extends MaskFormatter.MaskCharacter {
+
+        /**
+        * Valida se a string é uma letra do alfabeto (a-z) ou um numero entre zero e nove.
+        * 
+        * @param aChar - String passada para validação.
+        * @returns - Verdadeiro se a string passada for uma letra do alfabeto ou um numeral (de 0 a 9).
+        */ 
+        public isValidCharacter(aChar: string): boolean {
+            //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata.
+            return (/[a-z0-9]/i.test(aChar)) && super.isValidCharacter(aChar);
+        }
+    }
+
+    private static CharCharacter = class extends MaskFormatter.MaskCharacter {
+        /**
+        * Valida se a string é uma letra do alfabeto (a-z).
+        * 
+        * @param aChar - String passada para validação.
+        * @returns - Verdadeiro se a string passada for uma letra do alfabeto.
+        */ 
+        public isValidCharacter(aChar: string): boolean {
+            //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata
+            return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
+        }
+
+    }
+
+}
+
+export namespace MaskFormatter {
+    export type MaskCharacter = InstanceType<typeof MaskFormatter.MaskCharacter>;
+}