@sankhyalabs/ezui 1.1.76 → 1.1.77

package/dist/esm/RequestMetadata-c265c9d5.js

@@ -1,527 +0,0 @@
-const NUMBERINPUTS_REGEX_SCIENTIFIC_PARTS = /^([+-])?(\d+).?(\d*)[eE]([-+]?\d+)$/;
-/**
- * `NumberUtils` é uma biblioteca para manipulação de números
- *
- * `Métodos`:
- *
- * @stringToNumber: converte um número em formato de string em um valor numérico nativo do javascript
- * @format: arredonda um número em formato de string baseado nos parâmetros "presision" e "prettyPrecision";
- */
-class NumberUtils {
-}
-/**
-* @stringToNumber: converte um numero em formato de string em numero
-*
-* @param value numero em formato de string a ser convertido (Importante: formato PT-BR ou já em formato numérico: ######.##)
-*
-* @returns string based number
-*
-* @Exemples
-* @"100,12"     |       100.12
-* @"100.12"     |       100.12
-* @"-100,12"    |       -100.12
-* @"R$100,12"   |       100.12
-* @"-R$100,12"  |       -100.12
-* @"string"     |       NaN
-*/
-NumberUtils.stringToNumber = (value) => {
-    if (value === '' || value === null || value === undefined) {
-        return NaN;
-    }
-    if (value) {
-        value = value.toString();
-        var negative = (value.charAt(0) === '-');
-        if (!NUMBERINPUTS_REGEX_SCIENTIFIC_PARTS.test(value)) {
-            value = value.replace(/[^\d.,]/g, '');
-        }
-        else {
-            value = value.replace(/^-/g, '');
-        }
-        //In case of simple string such as: "@@@@@@@"
-        if (value === '') {
-            return Number(NaN);
-        }
-        var indexV = value.indexOf(',');
-        var indexP = value.indexOf('.');
-        if (indexP > indexV) {
-            value = value.replace(',', '');
-        }
-        else if (indexP < indexV) {
-            value = value.replace(/\./g, '@').replace(',', '.').replace(/@/g, '');
-        }
-        if (negative) {
-            value = '-' + value;
-        }
-    }
-    return Number(value);
-};
-/**
-* @format: converte um numero em formato de string em um numero em formato de string formatado de acordo com os parametros de "precision" e "prettyPrecision"
-*
-* @param value numero em formato de string a ser convertido (Importante: formato PT-BR ou já em formato numérico<sem separadors de milhares>: ######.##)
-* @param precision (numero de decimais)
-* @param prettyPrecision (numero de zeros nos decimais)
-*
-* @returns numero em formato de string formatado em PT-BR
-*/
-NumberUtils.format = (value, precision, prettyPrecision = NaN) => {
-    if (value === '' || value === undefined || value === "NaN") {
-        return NaN.toString();
-    }
-    let newValue = NumberUtils.stringToNumber(value);
-    if (newValue === NaN) {
-        return NaN.toString();
-    }
-    //Validation "precision":
-    // Case1: precision < 0 => does not use precision
-    // Case2: presicion not int => does not use precision
-    if (precision < 0 || Math.abs(Math.round(precision * 1) / 1) !== precision) {
-        //Once stringToNumber returns number format, we need to change to pt-br
-        return NumberUtils.changeFormat(newValue.toString());
-    }
-    //Validation "prettyPrecision"
-    let prettyPrecisionInternal = 0;
-    // Case1: prettyPrecision < 0 => prettyPrecision does not change de format that means: prettyPrecisionInternal = precision;
-    // Case2: prettyPrecision not int => prettyPrecision does not change de format that means: prettyPrecisionInternal = precision;
-    if (prettyPrecision === NaN || Math.abs(Math.round(prettyPrecision * 1) / 1) !== prettyPrecision) {
-        prettyPrecisionInternal = precision;
-    }
-    else {
-        prettyPrecisionInternal = prettyPrecision;
-    }
-    let newValueStr;
-    newValueStr = (Math.round(newValue * Math.pow(10, precision)) / Math.pow(10, precision)).toLocaleString('pt-br', { minimumFractionDigits: precision });
-    //prettyPrecision
-    const varSettingPP = precision - prettyPrecisionInternal;
-    if (varSettingPP > 0) {
-        for (let i = 0; i < varSettingPP; i++) {
-            if (newValueStr.substring(newValueStr.length - 1) == "0" && precision > 0) {
-                newValueStr = newValueStr.substring(0, newValueStr.length - 1);
-            }
-        }
-    }
-    //in Case "." or "," in the end of the string
-    if (newValueStr.substring(newValueStr.length - 1) == "." || newValueStr.substring(newValueStr.length - 1) == ",") {
-        newValueStr = newValueStr.substring(0, newValueStr.length - 1);
-    }
-    return newValueStr;
-};
-/**
-* @keepOnlyDecimalSeparator: retira os separadores de milhar de um número em formato de string
-*
-* @param value numero em formato de string a ser convertido
-* @param formatnumber (formatação de ENTRADA e SAÍDA do utilitário: pt-BR="###.###,##" en-US="###,###.##"; Default: "pt-BR")
-*
-* @returns numero em formato de string formatado apenas com separador decimal
-*/
-NumberUtils.keepOnlyDecimalSeparator = (value, formatnumber = 'pt-BR') => {
-    //Formatting formatnumber to be able to get lowercases
-    formatnumber = formatnumber.toUpperCase();
-    //Formatting value following formatnumber parameter
-    //keep only decimal character in order to correct format the string
-    //This transformation is due the "stringtoNumber" method is a general method that tries to convert all formated strings
-    if (formatnumber === 'EN-US') {
-        value = value.replace(/\,/g, '');
-    }
-    else {
-        value = value.replace(/\./g, '');
-    }
-    return value;
-};
-/**
-* @changeFormat: troca o formato do numero string de "PT-BR" para "EN-US" e vice-versa
-*
-* @param value numero em formato de string a ser convertido
-*
-* @returns numero em formato de string formatado de "PT-BR" para "EN-US" e vice-versa
-*/
-NumberUtils.changeFormat = (value) => {
-    //Formatting output following formatnumber
-    return value.replace(/\./g, '_').replace(/\,/g, '.').replace(/\_/g, ',');
-};
-
-/**
- * `MaskFormatter` é usado para formatar strings. Seu comportamento
- * é controlado pela 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 maiú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 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.
- *
- * For 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           |
- *
- */
-class MaskFormatter {
-    constructor(mask) {
-        this._mask = '';
-        this._maskChars = new Array();
-        /**
-         * 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
-         */
-        this.placeholder = ' ';
-        this.mask = mask;
-    }
-    /**
-     * Setter para mask. Trata-se do padrão que se espera ao formatar o texto.
-     */
-    set mask(mask) {
-        this._mask = mask;
-        this.updateInternalMask();
-    }
-    /**
-     * Getter para mask
-     *
-     * @return A última máscara informada.
-     */
-    get mask() {
-        return this._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
-     */
-    format(value) {
-        let result = '';
-        const index = [0];
-        let counter = 0;
-        const maxCounter = this._maskChars.length;
-        while (counter < maxCounter) {
-            result = this._maskChars[counter].append(result, value, index);
-            counter++;
-        }
-        return result;
-    }
-    /**
-     * Preparamos a formatação internamente de acordo com o padrão.
-     */
-    updateInternalMask() {
-        this._maskChars.length = 0;
-        if (this.mask != null) {
-            let counter = 0;
-            const maxCounter = this.mask.length;
-            while (counter < maxCounter) {
-                let maskChar = 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++;
-            }
-        }
-    }
-}
-MaskFormatter.DIGIT_KEY = "#";
-MaskFormatter.LITERAL_KEY = "'";
-MaskFormatter.UPPERCASE_KEY = "U";
-MaskFormatter.LOWERCASE_KEY = "L";
-MaskFormatter.ALPHA_NUMERIC_KEY = "A";
-MaskFormatter.CHARACTER_KEY = "?";
-MaskFormatter.ANYTHING_KEY = "*";
-//
-// Classes internas usadas para representar a máscara.
-//
-MaskFormatter.MaskCharacter = class {
-    constructor(maskFormatter, type) {
-        this.maskFormatter = maskFormatter;
-        this.type = type;
-    }
-    /**
-     * Cada subclasse deve sobrescrever o retornando true, caso represente
-     * um caractere literal. Por padrão o retorno é false.
-     */
-    isLiteral() {
-        return false;
-    }
-    /**
-     * Returns true if <code>aChar</code> is a valid reprensentation of
-     * the receiver. The default implementation returns true if the
-     * receiver represents a literal character and <code>getChar</code>
-     * == aChar. Otherwise, this will return true is <code>aChar</code>
-     * is contained in the valid characters and not contained
-     * in the invalid characters.
-     */
-    isValidCharacter(aChar) {
-        if (this.isLiteral()) {
-            return (this.getChar(aChar) == aChar);
-        }
-        aChar = this.getChar(aChar);
-        return true;
-    }
-    /**
-     * Returns the character to insert for <code>aChar</code>. The
-     * default implementation returns <code>aChar</code>. Subclasses
-     * that wish to do some sort of mapping, perhaps lower case to upper
-     * case should override this and do the necessary mapping.
-     */
-    getChar(aChar) {
-        return aChar;
-    }
-    /**
-     * Appends the necessary character in <code>formatting</code> at
-     * <code>index</code> to <code>buff</code>.
-     */
-    append(result, formatting, index) {
-        const inString = index[0] < formatting.length;
-        const aChar = inString ? formatting.charAt(index[0]) : '';
-        if (this.isLiteral()) {
-            const literal = 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;
-    }
-    getFormatMessage() {
-        let message;
-        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;
-    }
-};
-MaskFormatter.LiteralCharacter = class extends MaskFormatter.MaskCharacter {
-    constructor(maskFormatter, fixedChar) {
-        super(maskFormatter, fixedChar);
-        this._fixedChar = fixedChar;
-    }
-    isLiteral() {
-        return true;
-    }
-    getChar(aChar) {
-        return this._fixedChar;
-    }
-};
-MaskFormatter.DigitMaskCharacter = class extends MaskFormatter.MaskCharacter {
-    isValidCharacter(aChar) {
-        return (this.isDigit(aChar) && super.isValidCharacter(aChar));
-    }
-    isDigit(char) {
-        return char >= '0' && char <= '9';
-    }
-};
-MaskFormatter.UpperCaseCharacter = class extends MaskFormatter.MaskCharacter {
-    isValidCharacter(aChar) {
-        return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
-    }
-    getChar(aChar) {
-        return aChar.toUpperCase();
-    }
-};
-MaskFormatter.LowerCaseCharacter = class extends MaskFormatter.MaskCharacter {
-    isValidCharacter(aChar) {
-        return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
-    }
-    getChar(aChar) {
-        return aChar.toLocaleLowerCase();
-    }
-};
-MaskFormatter.AlphaNumericCharacter = class extends MaskFormatter.MaskCharacter {
-    isValidCharacter(aChar) {
-        //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata
-        return (/[a-z0-9]/i.test(aChar)) && super.isValidCharacter(aChar);
-    }
-};
-MaskFormatter.CharCharacter = class extends MaskFormatter.MaskCharacter {
-    isValidCharacter(aChar) {
-        //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata
-        return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
-    }
-};
-
-/**
- * `TimeFormatter` é um utilitário para formatação de strings desformatadas em strings válidas de horários
- */
-class TimeFormatter {
-    /**
-    * @prepareValue: converts an unformated time string into a formatted time.
-    *
-    * @param value unformated time string to convert
-    *
-    * @returns formatted time string
-    *
-    * @Exemples
-    * @"1012"       |       "10:12"
-    * @"10:12"      |       "10:12:00"
-    * @"100112"     |       "10:01:12"
-    */
-    static prepareValue(value, showSeconds) {
-        if (value && value.length > 0 && value != "NaN") {
-            let validationValue = value.replace(/:/g, "");
-            if (showSeconds) {
-                this._maskFormatter.mask = "##:##:##";
-                if (validationValue.length < 6) {
-                    while (validationValue.length < 6) {
-                        validationValue = "0".concat(validationValue);
-                    }
-                }
-            }
-            else {
-                this._maskFormatter.mask = "##:##";
-                if (validationValue.length < 4) {
-                    while (validationValue.length < 4) {
-                        validationValue = "0".concat(validationValue);
-                    }
-                }
-            }
-            if (this._maskFormatter) {
-                try {
-                    value = this._maskFormatter.format(validationValue);
-                    return value;
-                }
-                catch (e) {
-                    throw new Error(e.message);
-                }
-            }
-        }
-        return '';
-    }
-    /**
-    * @validateTime: validates if an input string has the corect time format.
-    *
-    * @param value input string to validate
-    *
-    * @returns true or false
-    *
-    * @Exemples
-    * @"1012"       |       true
-    * @"14e4"       |       false
-    * @"2624"       |       false
-    */
-    static validateTime(value, showSeconds) {
-        let isValid = true;
-        if (value) {
-            let validationValue = value.replace(/:/g, "");
-            if (showSeconds) {
-                if (!["1", "2", "0"].includes(validationValue[0])) {
-                    isValid = false;
-                }
-                if (!["0", "1", "2", "3", "4", "5"].includes(validationValue[2])) {
-                    isValid = false;
-                }
-                if (!["0", "1", "2", "3", "4", "5"].includes(validationValue[4])) {
-                    isValid = false;
-                }
-                if (validationValue[0] == "2" && !["0", "1", "2", "3"].includes(validationValue[1])) {
-                    isValid = false;
-                }
-            }
-            else {
-                if (!["1", "2", "0"].includes(validationValue[0])) {
-                    isValid = false;
-                }
-                if (!["0", "1", "2", "3", "4", "5"].includes(validationValue[2])) {
-                    isValid = false;
-                }
-                if (validationValue[0] == "2" && !["0", "1", "2", "3"].includes(validationValue[1])) {
-                    isValid = false;
-                }
-            }
-        }
-        else {
-            isValid = false;
-        }
-        return isValid;
-    }
-}
-TimeFormatter._maskFormatter = new MaskFormatter("##:##");
-
-/**
- * Representa as propriedades necessárias para se executar uma requisição.
- */
-/** Representa os verbos HTTP suportados */
-var Method;
-(function (Method) {
-    Method[Method["GET"] = 0] = "GET";
-    Method[Method["PUT"] = 1] = "PUT";
-    Method[Method["POST"] = 2] = "POST";
-    Method[Method["DELETE"] = 3] = "DELETE";
-})(Method || (Method = {}));
-
-export { MaskFormatter as M, NumberUtils as N, TimeFormatter as T };