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

package/src/utils/NumberUtils.ts

@@ -0,0 +1,283 @@
+import { StringUtils } from "./StringUtils.js";
+
+const NUMBERINPUTS_REGEX_SCIENTIFIC_PARTS: RegExp = /^([+-])?(\d+).?(\d*)[eE]([-+]?\d+)$/;
+
+/**
+ * `NumberUtils`: Utilizado para manipulação de numerais.
+ */
+export class NumberUtils {
+    /**
+    * Converte o dado numérico de string para number.
+    * 
+    * @param value Numeral em formato de string a ser convertido (Importante: formato PT-BR ou já em formato numérico: ######.##).
+    * @returns - Numeral passado.
+    * @example
+    * @"100,12"     |       100.12
+    * @"100.12"     |       100.12
+    * @"-100,12"    |       -100.12
+    * @"R$100,12"   |       100.12
+    * @"-R$100,12"  |       -100.12
+    * @"string"     |       NaN
+    */
+    static stringToNumber = (value: string): number => {
+
+        if (value === '' || value === null || value === undefined) {
+            return NaN;
+        }
+
+        if (value) {
+            value = value.toString();
+
+            const 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);
+            }
+
+            const indexV = value.indexOf(',');
+            const 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);
+
+    }
+
+
+    /**
+    * Formata o numeral com a precisão informada.
+    * 
+    * @param value - Numeral em formato de string a ser convertido (Importante: formato PT-BR ou já em formato numérico - sem separador de milhares: ######.##).
+    * @param precision - Quantidade de casas decimais.
+    * @param prettyPrecision - Quantidade de zeros nos decimais.
+    * @param defaultValue - Valor padrão caso o value não seja um valor numérico válido.
+    * 
+    * @returns - Numeral em formato de String formatado em PT-BR.
+    * @example
+    * Informado: ('10,9845444', 3, 3) | Retorna: '10,985'
+    * Informado: (undefined, 3, 3) | Retorna: NaN
+    * Informado: (undefined, 3, 3, '0,00') | Retorna: 0,00
+    */
+    static format = (value: string, precision: number, prettyPrecision: number = NaN, defaultValue:string = NaN.toString()): string => {
+
+        if (value === '' || value === undefined || value === "NaN") {
+            return defaultValue;
+        }
+
+        const newValue: number = NumberUtils.stringToNumber(value);
+
+        if (isNaN(newValue)) {
+            return defaultValue;
+        }
+
+        //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: number = 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 (isNaN(prettyPrecision) || Math.abs(Math.round(prettyPrecision * 1) / 1) !== prettyPrecision) {
+            prettyPrecisionInternal = precision;
+        } else {
+            prettyPrecisionInternal = prettyPrecision;
+        }
+
+        let newValueStr: string;
+        newValueStr = (Math.round(newValue * Math.pow(10, precision)) / Math.pow(10, precision)).toLocaleString('pt-br', { minimumFractionDigits: precision });
+
+        //prettyPrecision
+        const varSettingPP: number = 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;
+    }
+
+
+    /**
+    * Formata o numeral com a precisão informada e o valor default 0,00 caso o value não seja um numero valido.
+    * 
+    * @param value - Numeral em formato de string a ser convertido (Importante: formato PT-BR ou já em formato numérico - sem separador de milhares: ######.##).
+    * @param precision - Quantidade de casas decimais.
+    * @param prettyPrecision - Quantidade de zeros nos decimais.
+    * 
+    * @returns - Numeral em formato de String formatado em PT-BR.
+    * @example
+    * Informado: ('10,9845444', 3, 3) | Retorna: '10,985'
+    * Informado: (undefined, 3, 3) | Retorna: 0,00
+    */
+     static safeFormat = (value: string, precision: number, prettyPrecision: number = NaN): string => {
+        return NumberUtils.format(value, precision, prettyPrecision, "0,00");
+     }
+
+
+    /**
+    * Retira os separadores de milhar de um numeral em formato de string.
+    * 
+    * @param value - Numeral 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 - Numeral em formato de string formatado apenas com separador decimal.
+    * @example
+    * Informado: '95.12' | Retorna: '9512'
+    */
+    static keepOnlyDecimalSeparator = (value: string, formatnumber: string = 'pt-BR'): string => {
+
+        //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;
+    }
+
+    /**
+    * Troca o formato do numeral(string) de "PT-BR" para "EN-US" e vice-versa.
+    * 
+    * @param value - Numeral em formato de string a ser convertido.
+    * 
+    * @returns - Numeral em formato de string formatado de "PT-BR" para "EN-US" e vice-versa.
+    * @example
+    * Informo: "15,55"     | Obtenho: "15.55"
+    * @example
+    * Informo: "27.99"     | Obtenho: "27,99"
+    */
+    static changeFormat = (value: string): string => {
+        //Formatting output following formatnumber
+        return value.replace(/\./g, '_').replace(/\,/g, '.').replace(/\_/g, ',');
+    }
+
+
+
+    /**
+    * Obtém o valor ou o valor padrão, caso o valor seja inválido(NaN/undefined).
+    * 
+    * @param value - Valor a ser validado.
+    * @param defaultValue - Valor padrão a ser retornado caso o value seja inválido.
+    * 
+    * @returns - O próprio numeral passado ou zero.
+    * 
+    * @example
+    * Informo: value: 30, defaultValue: 0     | Obtenho: 30
+    * @example
+    * Informo: value: "30", defaultValue: 0   | Obtenho: 30
+    * @example
+    * Informo: value: "30abc", defaultValue: 0   | Obtenho: 0
+    */
+    static getValueOrDefault = (value: any, defaultValue: number): number => {
+        value = StringUtils.isEmpty(value) ? undefined : value;
+        value = Number(value);
+
+        if (isNaN(value)){
+            return Number(defaultValue);
+        }
+
+        return value;
+
+    }
+
+    /**
+    * Obtém o valor ou zero, caso o valor seja inválido(NaN/undefined).
+    * 
+    * @param value - Numeral a ser validado.
+    * 
+    * @returns - O próprio numeral passado. Caso esse seja inválido retorna zero.
+    */
+     static getValueOrZero = (value: any): number => {
+        return NumberUtils.getValueOrDefault(value, 0);
+    }
+
+    /**
+    * Realiza o arredondamento de casas decimais de um numero.
+    * 
+    * @param value - Numeral a ser arredondado.
+    * @param decimals - Quantidade de casas decimais ussada no arredondamento.
+    * 
+    * @returns - O próprio numeral arredondado com a quantidade de casas decimais do argumento decimals.
+    * 
+    * @example
+    * Informo: (100.12)       |   100.12
+    * Informo: (100,12)       |   NaN
+    
+    * Informo: ("100.12", 1)  |   100.1
+    * Informo: ("100.12", 2)  |   100.12
+    * Informo: ("100.12", 3)  |   100.12
+    
+    * Informo: ("100.15", 1)  |   100.2
+    * Informo: ("100.15", 2)  |   100.15
+    * Informo: ("100.15", 3)  |   100.15
+    
+    * Informo: ("100.16", 1)  |   100.2
+    * Informo: ("100.16", 2)  |   100.16
+    * Informo: ("100.16", 3)  |   100.16
+    */
+    static round(value: number, decimals: number = 2):number {
+        const multiplier = 10 ** decimals;
+        return Math.round(value * multiplier) / multiplier;
+    }
+
+     /**
+     * Determina a ordem de umeros.
+     *
+     * @param a - Primeio número para comparação.
+     * @param b - Segundo número para comparação.
+     * @returns - Um numeral negativo se o primeiro argumento é menor que o segundo, zero se os dois são iguais e um numeral positivo quando o primeiro é maior que o segundo.
+     */
+    static compare(a: number, b: number): number{
+
+        if(a === undefined){
+            return b === undefined ? 0 : 1;
+        } else if(b === undefined){
+            return -1;
+        }
+
+        if(a === null){
+            return b === null ? 0 : 1;
+        } else if(b === null){
+            return -1;
+        }
+
+        return a > b ? 1 : (a < b ? -1 : 0);
+    }
+}

package/src/utils/ObjectUtils.ts

@@ -0,0 +1,76 @@
+/**
+ * `ObjectUtils`: Utilizado para manipulação de objetos.
+ */
+export default class ObjectUtils{
+
+
+    /**
+     * Faz a cópia do objeto.
+     * 
+     * @param data - Objeto a ser copiado.
+     * @returns - A cópia do objeto válido.
+     */ 
+    public static copy<T>(data:Object | Array<Object>): T {
+        return this.stringToObject(this.objectToString(data)) as T;
+    }
+
+    /**
+     * Converte um objeto em string/JSON.
+     * 
+     * @param data - Objeto a ser convertido.
+     * @returns - Uma string JSON.
+     * 
+     * @example
+     * @Informado: ```{nome : "Sankhya", cidade: "Uberlandia"}``` | Obtenho: ```"{"nome" : "Sankhya", "cidade":"Uberlandia"}"```
+     */ 
+    public static objectToString(data:Object | Array<Object>):string{
+        return JSON.stringify(data);
+    }
+
+    /**
+     * Converte uma string/JSON em objeto.
+     * 
+     * @param data - String a ser convertida.
+     * @returns - Um objeto válido.
+     * 
+     * @example
+     * Informado: ```"{"nome" : "Sankhya", "cidade":"Uberlandia"}"``` | Obtenho: ```{nome : "Sankhya", cidade: "Uberlandia"}```
+     */ 
+    public static stringToObject(data:string):Object | Array<Object>{
+        return JSON.parse(data)
+    }
+
+    /**
+     * Faz a ordenação de um objeto por uma propriedade.
+     * 
+     * @param data - Objeto a ser ordenado.
+     * @param property - Nome da propriedade a ser ordenada.
+     * @returns - O objeto ordenado pela propriedade.
+     */
+    public static sortByProperty(data: any, property: string): any {
+        return Object.keys(data)
+          .sort(function(keyA: string, keyB: string) { // Ordenação pela `property`
+            const x = data[keyA][property];
+            const y = data[keyB][property];
+            return x < y ? -1 : x > y ? 1 : 0;
+          }).reduce((obj: any, key: string) => { // Reconstrução do Objeto de retorno
+            obj[key] = data[key];
+            return obj;
+          }, {});
+    }
+    
+    /**
+     * Remove atributos nulos e indefinidos de um objeto.
+     * 
+     * @param data - Objeto a ser filtrado.
+     * @returns - O objeto com as propriedades válidas.
+     */    
+    public static removeEmptyValues(obj: object): object {
+      return Object.fromEntries(
+        Object.entries(obj)
+          .filter(([, v]) => v != null)
+          .map(([k, v]) => [k, v === Object(v) ? ObjectUtils.removeEmptyValues(v) : v])
+      );
+
+    }
+}

package/src/utils/OnboardingUtils.ts

@@ -0,0 +1,46 @@
+export class OnboardingUtils {
+    private static readonly USER_GUIDE_TAG_ID = "userGuideSnippet";
+    private static instance: OnboardingUtils;
+
+    private constructor(){}
+
+    public static getInstance(): OnboardingUtils {
+        if(this.instance == null){
+            this.instance = new OnboardingUtils();
+        }
+        return this.instance;
+    }
+
+    public init(apiKey: string, ctx: EnvironmentContext): Promise<void> {
+        if(!apiKey){
+            return Promise.resolve();
+        }
+        this.injectScript(apiKey);
+        this.register(ctx);
+        return Promise.resolve();
+    }
+
+    private injectScript(apiKey: string){
+        if(window.document.head.querySelector(`script#${OnboardingUtils.USER_GUIDE_TAG_ID}`)){
+            return;
+        }
+
+        const scriptEl = document.createElement('script');
+        scriptEl.setAttribute("id", OnboardingUtils.USER_GUIDE_TAG_ID);
+        scriptEl.innerText = `(function(g,u,i,d,e,s){g[e]=g[e]||[];var f=u.getElementsByTagName(i)[0];var k=u.createElement(i);k.async=true;k.src='https://static.userguiding.com/media/user-guiding-'+s+'-embedded.js';f.parentNode.insertBefore(k,f);if(g[d])return;var ug=g[d]={q:[]};ug.c=function(n){return function(){ug.q.push([n,arguments])};};var m=['previewGuide','finishPreview','track','identify','hideChecklist','launchChecklist'];for(var j=0;j<m.length;j+=1){ug[m[j]]=ug.c(m[j]);}})(window,document,'script','userGuiding','userGuidingLayer','${apiKey}');`;
+        window.document.head.appendChild(scriptEl);
+    }
+
+    private register(ctx: EnvironmentContext){
+        (window as any).userGuiding.identify(`${ctx.userID}-${ctx.userName}-${ctx.clientGaId}`, ctx);
+    }
+}
+
+export class EnvironmentContext {
+     userID: string = "";
+     userName: string = "";
+     partnerName: string = "";
+     sysVersion: string = "";
+     environment: string = "";
+     clientGaId: string = "";
+}

package/src/utils/ReadyUtil.ts

@@ -0,0 +1,45 @@
+/**
+ * `ReadyUtil`: Registra processos que serão invocados após a conclusão de operações.
+ */
+export default class ReadyUtil{
+    private resolve:any;
+    private promise:any;
+    
+    /**
+     * Limpa o estado da instancia ao finalizar a execução do processo registrado.
+     */
+    private clean() {
+        this.resolve = undefined;
+        this.promise = undefined;
+    }
+
+    /**
+     * Inicializa o estado da instancia ao registrar processo.
+     */
+    private start() {
+        if(!this.promise) this.promise = new Promise((accept) => { 
+            this.resolve = () => accept(true); 
+        })
+    }
+
+    /**
+     * Executa processo atribuído.
+     */
+    end(){
+        this.resolve && this.resolve();
+    }
+
+    /**
+     *  Atribui processo que será executado por operações que o invocarem no método 'end'.
+     * @returns Promise que deve conter o código do processo.
+     */
+    whenReady(){
+        this.start();
+        return new Promise((accept) => {
+            this.promise.then(() => { 
+                accept(true);
+                this.clean();
+            });
+        });
+    }
+}