@senior-agronegocio/angular-components 0.0.9883 → 1.0.0

package/esm2022/common/agro-object-utils.class.mjs

@@ -0,0 +1,320 @@
+import moment from "moment";
+import { AGRO_NUMBERS } from "../enums";
+export { AgroObjectUtils as AOU, AgroObjectUtils as ObjectUtils };
+// Local enum for field types instead of importing from external package
+var FieldType;
+(function (FieldType) {
+    FieldType["String"] = "String";
+    FieldType["Date"] = "Date";
+    FieldType["Money"] = "Money";
+})(FieldType || (FieldType = {}));
+/**
+ * Classe utilitária para operações de objeto.
+ */
+export class AgroObjectUtils {
+    /**
+     * Verifica se um objeto é nulo ou indefinido.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for nulo ou indefinido, false caso contrário.
+     */
+    static isNullOrUndefined(obj) {
+        return obj === null || obj === undefined;
+    }
+    /**
+     * Verifica se um objeto não é nulo e não é indefinido.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto não for nulo e não for indefinido, false caso contrário.
+     */
+    static isNotNullOrUndefined(obj) {
+        return !AgroObjectUtils.isNullOrUndefined(obj);
+    }
+    /**
+     * Verifica se um objeto é uma string.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for uma string, false caso contrário.
+     */
+    static isString(obj) {
+        return typeof obj === "string";
+    }
+    /**
+     * Verifica se um objeto é um número.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for um número, false caso contrário.
+     */
+    static isNumber(obj) {
+        return typeof obj === "number";
+    }
+    /**
+     * Verifica se um objeto é um booleano.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for um booleano, false caso contrário.
+     */
+    static isBoolean(obj) {
+        return typeof obj === "boolean";
+    }
+    /**
+     * Verifica se um objeto é uma função.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for uma função, false caso contrário.
+     */
+    static isFunction(obj) {
+        return typeof obj === "function";
+    }
+    /**
+     * Verifica se um objeto é um array.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for um array, false caso contrário.
+     */
+    static isArray(obj) {
+        return Array.isArray(obj);
+    }
+    /**
+     * Verifica se o valor informado é um objeto.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for um objeto, false caso contrário.
+     */
+    static isObject(obj) {
+        return typeof obj === "object";
+    }
+    /**
+     * Verifica se um objeto é uma data.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for uma data, false caso contrário.
+     */
+    static isDate(obj) {
+        return obj instanceof Date;
+    }
+    /**
+     * Verifica se um objeto é um erro.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for um erro, false caso contrário.
+     */
+    static isError(obj) {
+        return obj instanceof Error;
+    }
+    /**
+     * Verifica se um objeto é uma expressão regular.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for uma expressão regular, false caso contrário.
+     */
+    static isRegExp(obj) {
+        return obj instanceof RegExp;
+    }
+    /**
+     * Verifica se um objeto é um valor primitivo.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for um valor primitivo, false caso contrário.
+     */
+    static isPrimitive(obj) {
+        return AgroObjectUtils.isString(obj) || AgroObjectUtils.isNumber(obj) || AgroObjectUtils.isBoolean(obj);
+    }
+    /**
+     * Verifica se todos os valores de um objeto são nulos ou indefinidos.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se todos os valores do objeto forem nulos ou indefinidos, false caso contrário.
+     */
+    static allNull(obj) {
+        if (!AgroObjectUtils.isObject(obj)) {
+            return false;
+        }
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key) && !AgroObjectUtils.isNullOrUndefined(obj[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static compareArrays(arr1, arr2) {
+        if (arr1.length !== arr2.length) {
+            return false;
+        }
+        return arr1.every((v, i) => AgroObjectUtils.isEqual(v, arr2[i]));
+    }
+    static compareObjects(obj1, obj2) {
+        const keys1 = Object.keys(obj1);
+        const keys2 = Object.keys(obj2);
+        if (keys1.length !== keys2.length) {
+            return false;
+        }
+        return keys1.every((key) => obj2.hasOwnProperty(key) && AgroObjectUtils.isEqual(obj1[key], obj2[key]));
+    }
+    /**
+     * Compara dois objetos para verificar se são iguais.
+     * @param obj1 - O primeiro objeto a ser comparado.
+     * @param obj2 - O segundo objeto a ser comparado.
+     * @returns True se os objetos forem iguais, false caso contrário.
+     */
+    static isEqual(obj1, obj2) {
+        if (obj1 === obj2) {
+            return true;
+        }
+        if (obj1 === null || obj2 === null || typeof obj1 !== "object" || typeof obj2 !== "object") {
+            return false;
+        }
+        if (Array.isArray(obj1) && Array.isArray(obj2)) {
+            return this.compareArrays(obj1, obj2);
+        }
+        if (Array.isArray(obj1) || Array.isArray(obj2)) {
+            return false;
+        }
+        return this.compareObjects(obj1, obj2);
+    }
+    /**
+     * Verifica se um objeto é nulo.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for nulo ou um objeto vazio, false caso contrário.
+     */
+    static isNull(obj) {
+        return obj === null;
+    }
+    /**
+     * Verifica se um objeto não é nulo.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto não for nulo, false caso contrário.
+     */
+    static isNotNull(obj) {
+        return !AgroObjectUtils.isNull(obj);
+    }
+    /**
+     * Converte um objeto para uma string JSON.
+     * @param obj - O objeto a ser convertido.
+     * @returns A string JSON representando o objeto.
+     */
+    static toJSON(obj) {
+        return JSON.stringify(obj);
+    }
+    /**
+     * Verifica se um objeto não é vazio.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto não for vazio, false caso contrário.
+     */
+    static isNotEmpty(obj) {
+        if (!AgroObjectUtils.isObject(obj)) {
+            return false;
+        }
+        return Object.keys(obj).length !== AGRO_NUMBERS.ZERO;
+    }
+    /**
+     * Verifica se um objeto é vazio.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for vazio, false caso contrário.
+     */
+    static isEmpty(obj) {
+        return !AgroObjectUtils.isNotEmpty(obj);
+    }
+    /**
+     * Verifica se um objeto não está vazio e contém uma determinada propriedade.
+     * @param obj - O objeto a ser verificado.
+     * @param property - A propriedade a ser verificada.
+     * @returns True se o objeto não estiver vazio e contiver a propriedade, false caso contrário.
+     */
+    static containsProperty(obj, property) {
+        return AgroObjectUtils.isNotEmpty(obj) && obj.hasOwnProperty(property);
+    }
+    /**
+     * Verifica se o parâmetro recebido é um objeto e se ele contém a propriedade ID.
+     */
+    static hasId(obj) {
+        return AgroObjectUtils.isNotEmpty(obj) && obj.hasOwnProperty("id");
+    }
+    /**
+     * Verifica se o valor informado no parâmetro possui as propriedades de uma entidade SDL (id e createdAt).
+     * @param obj
+     * @returns
+     */
+    static isSDLEntity(obj) {
+        return AgroObjectUtils.isNotEmpty(obj) && obj.hasOwnProperty("id") && obj.hasOwnProperty("createdAt");
+    }
+    /**
+     * Verifica se um objeto é valido, considerando que haja no mínimo 1 propriedade
+     */
+    static isValid(obj) {
+        return Object.keys(obj).length > AGRO_NUMBERS.ZERO && AgroObjectUtils.isNotEmpty(obj);
+    }
+    /**
+     * Verifica se um objeto é inválido, considerando que não haja nenhuma propriedade
+     */
+    static isInvalid(obj) {
+        return !AgroObjectUtils.isValid(obj);
+    }
+    /**
+     * Encontra uma propriedade em um objeto pelo nome e retorna seu valor.
+     * Se o valor for um objeto, retorna o próprio objeto.
+     *
+     * @param obj O objeto onde buscar.
+     * @param key O nome da propriedade a ser encontrada.
+     * @param deepSearch Indica se a busca deve ser em profundidade (padrão: true).
+     * @returns O valor da propriedade, ou undefined se não for encontrada.
+     */
+    static findProperty(obj, key, deepSearch = true) {
+        if (AgroObjectUtils.isInvalid(obj)) {
+            throw new Error("O primeiro argumento deve ser um objeto.");
+        }
+        if (key in obj) {
+            return obj[key];
+        }
+        if (deepSearch) {
+            for (const prop in obj) {
+                if (obj.hasOwnProperty(prop) && typeof obj[prop] === "object") {
+                    const result = AgroObjectUtils.findProperty(obj[prop], key, deepSearch);
+                    if (result !== undefined) {
+                        return result;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Recebe uma string (JSON) e tenta converter para um objeto.
+     * @param value
+     */
+    static fromString(value) {
+        try {
+            return JSON.parse(value);
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    /**
+     * Copia as propriedades explicitadas de um objeto para outro
+     * @param obj
+     * @param keys
+     * @returns
+     */
+    static pick(obj, keys) {
+        const result = {};
+        for (const key of keys) {
+            result[key] = obj[key];
+        }
+        return result;
+    }
+    /**
+     * Retorna o valor de uma propriedade de um objeto, formatado conforme o tipo especificado.
+     *
+     * @param obj - O objeto do qual a propriedade será extraída.
+     * @param path - O caminho da propriedade no objeto (pode ser um caminho aninhado).
+     * @param type - O tipo de formatação a ser aplicada (String, Date, Money).
+     * @returns O valor formatado da propriedade.
+     */
+    static getPropAndFormatValue(obj, path, type) {
+        const r = path.split(".").reduce((result, prop) => (result[prop] === undefined ? "" : result[prop]), obj);
+        if (!r) {
+            return "";
+        }
+        if (type === FieldType.String) {
+            return r;
+        }
+        else if (type === FieldType.Date) {
+            return moment(r).format("L");
+        }
+        else if (type === FieldType.Money) {
+            return Number(r).toLocaleString("pt-BR", { style: "currency", currency: "BRL" });
+        }
+        else {
+            return r;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agro-object-utils.class.js","sourceRoot":"","sources":["../../../projects/angular-components/common/agro-object-utils.class.ts"],"names":[],"mappings":"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","sourcesContent":["import moment from \"moment\";\r\nimport { AGRO_NUMBERS } from \"../enums\";\r\n\r\nexport { AgroObjectUtils as AOU, AgroObjectUtils as ObjectUtils };\r\n\r\n// Local enum for field types instead of importing from external package\r\nenum FieldType {\r\n    String = \"String\",\r\n    Date = \"Date\",\r\n    Money = \"Money\"\r\n}\r\n\r\n/**\r\n * Classe utilitária para operações de objeto.\r\n */\r\nexport class AgroObjectUtils {\r\n    /**\r\n     * Verifica se um objeto é nulo ou indefinido.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for nulo ou indefinido, false caso contrário.\r\n     */\r\n    static isNullOrUndefined(obj: any): boolean {\r\n        return obj === null || obj === undefined;\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto não é nulo e não é indefinido.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto não for nulo e não for indefinido, false caso contrário.\r\n     */\r\n    static isNotNullOrUndefined(obj: any): boolean {\r\n        return !AgroObjectUtils.isNullOrUndefined(obj);\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é uma string.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for uma string, false caso contrário.\r\n     */\r\n    static isString(obj: any): boolean {\r\n        return typeof obj === \"string\";\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é um número.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for um número, false caso contrário.\r\n     */\r\n    static isNumber(obj: any): boolean {\r\n        return typeof obj === \"number\";\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é um booleano.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for um booleano, false caso contrário.\r\n     */\r\n    static isBoolean(obj: any): boolean {\r\n        return typeof obj === \"boolean\";\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é uma função.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for uma função, false caso contrário.\r\n     */\r\n    static isFunction(obj: any): boolean {\r\n        return typeof obj === \"function\";\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é um array.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for um array, false caso contrário.\r\n     */\r\n    static isArray(obj: any): boolean {\r\n        return Array.isArray(obj);\r\n    }\r\n\r\n    /**\r\n     * Verifica se o valor informado é um objeto.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for um objeto, false caso contrário.\r\n     */\r\n    static isObject(obj: any): boolean {\r\n        return typeof obj === \"object\";\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é uma data.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for uma data, false caso contrário.\r\n     */\r\n    static isDate(obj: any): boolean {\r\n        return obj instanceof Date;\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é um erro.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for um erro, false caso contrário.\r\n     */\r\n    static isError(obj: any): boolean {\r\n        return obj instanceof Error;\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é uma expressão regular.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for uma expressão regular, false caso contrário.\r\n     */\r\n    static isRegExp(obj: any): boolean {\r\n        return obj instanceof RegExp;\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é um valor primitivo.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for um valor primitivo, false caso contrário.\r\n     */\r\n    static isPrimitive(obj: any): boolean {\r\n        return AgroObjectUtils.isString(obj) || AgroObjectUtils.isNumber(obj) || AgroObjectUtils.isBoolean(obj);\r\n    }\r\n\r\n    /**\r\n     * Verifica se todos os valores de um objeto são nulos ou indefinidos.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se todos os valores do objeto forem nulos ou indefinidos, false caso contrário.\r\n     */\r\n    static allNull(obj: any): boolean {\r\n        if (!AgroObjectUtils.isObject(obj)) {\r\n            return false;\r\n        }\r\n\r\n        for (const key in obj) {\r\n            if (obj.hasOwnProperty(key) && !AgroObjectUtils.isNullOrUndefined(obj[key])) {\r\n                return false;\r\n            }\r\n        }\r\n\r\n        return true;\r\n    }\r\n\r\n    private static compareArrays(arr1: unknown[], arr2: unknown[]): boolean {\r\n        if (arr1.length !== arr2.length) {\r\n            return false;\r\n        }\r\n        return arr1.every((v, i) => AgroObjectUtils.isEqual(v, arr2[i]));\r\n    }\r\n\r\n    private static compareObjects(obj1: object, obj2: object): boolean {\r\n        const keys1 = Object.keys(obj1);\r\n        const keys2 = Object.keys(obj2);\r\n        if (keys1.length !== keys2.length) {\r\n            return false;\r\n        }\r\n        return keys1.every((key) => (obj2 as any).hasOwnProperty(key) && AgroObjectUtils.isEqual((obj1 as any)[key], (obj2 as any)[key]));\r\n    }\r\n\r\n    /**\r\n     * Compara dois objetos para verificar se são iguais.\r\n     * @param obj1 - O primeiro objeto a ser comparado.\r\n     * @param obj2 - O segundo objeto a ser comparado.\r\n     * @returns True se os objetos forem iguais, false caso contrário.\r\n     */\r\n    static isEqual(obj1: unknown, obj2: unknown): boolean {\r\n        if (obj1 === obj2) {\r\n            return true;\r\n        }\r\n\r\n        if (obj1 === null || obj2 === null || typeof obj1 !== \"object\" || typeof obj2 !== \"object\") {\r\n            return false;\r\n        }\r\n\r\n        if (Array.isArray(obj1) && Array.isArray(obj2)) {\r\n            return this.compareArrays(obj1, obj2);\r\n        }\r\n\r\n        if (Array.isArray(obj1) || Array.isArray(obj2)) {\r\n            return false;\r\n        }\r\n\r\n        return this.compareObjects(obj1, obj2);\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é nulo.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for nulo ou um objeto vazio, false caso contrário.\r\n     */\r\n    static isNull(obj: any): boolean {\r\n        return obj === null;\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto não é nulo.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto não for nulo, false caso contrário.\r\n     */\r\n    static isNotNull(obj: any): boolean {\r\n        return !AgroObjectUtils.isNull(obj);\r\n    }\r\n\r\n    /**\r\n     * Converte um objeto para uma string JSON.\r\n     * @param obj - O objeto a ser convertido.\r\n     * @returns A string JSON representando o objeto.\r\n     */\r\n    static toJSON(obj: any): string {\r\n        return JSON.stringify(obj);\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto não é vazio.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto não for vazio, false caso contrário.\r\n     */\r\n    static isNotEmpty(obj: any): boolean {\r\n        if (!AgroObjectUtils.isObject(obj)) {\r\n            return false;\r\n        }\r\n        return Object.keys(obj).length !== AGRO_NUMBERS.ZERO;\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é vazio.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for vazio, false caso contrário.\r\n     */\r\n    static isEmpty(obj: any): boolean {\r\n        return !AgroObjectUtils.isNotEmpty(obj);\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto não está vazio e contém uma determinada propriedade.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @param property - A propriedade a ser verificada.\r\n     * @returns True se o objeto não estiver vazio e contiver a propriedade, false caso contrário.\r\n     */\r\n    static containsProperty(obj: any, property: string): boolean {\r\n        return AgroObjectUtils.isNotEmpty(obj) && obj.hasOwnProperty(property);\r\n    }\r\n\r\n    /**\r\n     * Verifica se o parâmetro recebido é um objeto e se ele contém a propriedade ID.\r\n     */\r\n    static hasId(obj: any): boolean {\r\n        return AgroObjectUtils.isNotEmpty(obj) && obj.hasOwnProperty(\"id\");\r\n    }\r\n\r\n    /**\r\n     * Verifica se o valor informado no parâmetro possui as propriedades de uma entidade SDL (id e createdAt).\r\n     * @param obj\r\n     * @returns\r\n     */\r\n    static isSDLEntity(obj: any): boolean {\r\n        return AgroObjectUtils.isNotEmpty(obj) && obj.hasOwnProperty(\"id\") && obj.hasOwnProperty(\"createdAt\");\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é valido, considerando que haja no mínimo 1 propriedade\r\n     */\r\n    static isValid(obj: any): boolean {\r\n        return Object.keys(obj).length > AGRO_NUMBERS.ZERO && AgroObjectUtils.isNotEmpty(obj);\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é inválido, considerando que não haja nenhuma propriedade\r\n     */\r\n    static isInvalid(obj: any): boolean {\r\n        return !AgroObjectUtils.isValid(obj);\r\n    }\r\n\r\n    /**\r\n     * Encontra uma propriedade em um objeto pelo nome e retorna seu valor.\r\n     * Se o valor for um objeto, retorna o próprio objeto.\r\n     *\r\n     * @param obj O objeto onde buscar.\r\n     * @param key O nome da propriedade a ser encontrada.\r\n     * @param deepSearch Indica se a busca deve ser em profundidade (padrão: true).\r\n     * @returns O valor da propriedade, ou undefined se não for encontrada.\r\n     */\r\n    static findProperty(obj: Record<string, any>, key: string, deepSearch: boolean = true): any {\r\n        if (AgroObjectUtils.isInvalid(obj)) {\r\n            throw new Error(\"O primeiro argumento deve ser um objeto.\");\r\n        }\r\n\r\n        if (key in obj) {\r\n            return obj[key];\r\n        }\r\n\r\n        if (deepSearch) {\r\n            for (const prop in obj) {\r\n                if (obj.hasOwnProperty(prop) && typeof obj[prop] === \"object\") {\r\n                    const result = AgroObjectUtils.findProperty(obj[prop], key, deepSearch);\r\n                    if (result !== undefined) {\r\n                        return result;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        return undefined;\r\n    }\r\n\r\n    /**\r\n     * Recebe uma string (JSON) e tenta converter para um objeto.\r\n     * @param value\r\n     */\r\n    static fromString(value: string): any {\r\n        try {\r\n            return JSON.parse(value);\r\n        } catch (e) {\r\n            return undefined;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Copia as propriedades explicitadas de um objeto para outro\r\n     * @param obj\r\n     * @param keys\r\n     * @returns\r\n     */\r\n    static pick<T, K extends keyof T>(obj: T, keys: readonly K[]): Pick<T, K> {\r\n        const result = {} as Pick<T, K>;\r\n        for (const key of keys) {\r\n            result[key] = obj[key];\r\n        }\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * Retorna o valor de uma propriedade de um objeto, formatado conforme o tipo especificado.\r\n     *\r\n     * @param obj - O objeto do qual a propriedade será extraída.\r\n     * @param path - O caminho da propriedade no objeto (pode ser um caminho aninhado).\r\n     * @param type - O tipo de formatação a ser aplicada (String, Date, Money).\r\n     * @returns O valor formatado da propriedade.\r\n     */\r\n    static getPropAndFormatValue(obj: any, path: any, type: FieldType) {\r\n        const r = path.split(\".\").reduce((result: any, prop: any) => (result[prop] === undefined ? \"\" : result[prop]), obj);\r\n        if (!r) {\r\n            return \"\";\r\n        }\r\n        if (type === FieldType.String) {\r\n            return r;\r\n        } else if (type === FieldType.Date) {\r\n            return moment(r).format(\"L\");\r\n        } else if (type === FieldType.Money) {\r\n            return Number(r).toLocaleString(\"pt-BR\", { style: \"currency\", currency: \"BRL\" });\r\n        } else {\r\n            return r;\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2022/common/agro-platform-utils.class.mjs

@@ -0,0 +1,119 @@
+import { AgroCookieUtils } from "./agro-cookie-utils.class";
+import { StringUtils } from "./agro-string-utils.class";
+// Cookie name constants
+const COOKIE_TOKEN = 'com.senior.token';
+const COOKIE_BASE_URL = 'com.senior.base.url';
+const COOKIE_SERVICES_URL = 'com.senior.services.url';
+export { AgroPlatformUtils as APU, AgroPlatformUtils as PlatformUtils };
+export class AgroPlatformUtils {
+    /**
+     * Retorna o tenant atual
+     * Caso contrário, retorna uma instância de Error
+     * @returns
+     */
+    static getCurrentTenant() {
+        const tenant = AgroPlatformUtils.getTokenField("tenantName");
+        if (tenant) {
+            return tenant;
+        }
+        throw new Error(`Cookie: "${COOKIE_TOKEN}" não encontrado.`);
+    }
+    /**
+     * Retorna o locale do tenant atual
+     *
+     * @returns
+     */
+    static getCurrentTenantLocale() {
+        const locale = AgroPlatformUtils.getTokenField("locale");
+        if (locale) {
+            return locale;
+        }
+        throw new Error(`'locale' não encontrado para o tenant atual.`);
+    }
+    /**
+     * @deprecated Use getCurrentTenantLocale()
+     * Mantido por compatibilidade retroativa.
+     */
+    static getCurrenTenantLocale() {
+        // legacy typo retained
+        return AgroPlatformUtils.getCurrentTenantLocale();
+    }
+    /**
+     * Retorna o nome completo do usuário logado
+     * Caso contrário, retorna uma instância de Error
+     * @returns string || null
+     */
+    static getCurrentUserName() {
+        const name = AgroPlatformUtils.getTokenField("fullName");
+        return name || null;
+    }
+    /**
+     * Retorna o nome de usuário logado
+     * Ex: admin@tenant.com.br
+     * Caso contrário, retorna uma instância de Error
+     * @returns string || null
+     */
+    static getCurrentUserUsername() {
+        const username = AgroPlatformUtils.getTokenField("username");
+        return username || null;
+    }
+    /**
+     * Retorna o e-mail do usuário logado
+     * Caso contrário, retorna uma instância de Error
+     * @returns string
+     */
+    static getCurrentUserEmail() {
+        const email = AgroPlatformUtils.getTokenField("email");
+        if (!email) {
+            console.info(`Cookie: "${COOKIE_TOKEN}" não encontrado.`);
+        }
+        return email || null;
+    }
+    /**
+     * Retorna uma string com a baseURL atual
+     * Caso contrário, retorna uma instância de Error
+     * @example "https://cloud-leaf.senior.com.br" || "https://platform.senior.com.br"
+     */
+    static getBaseURL() {
+        const cookie = AgroCookieUtils.getCookie(COOKIE_BASE_URL);
+        if (cookie) {
+            return decodeURIComponent(cookie);
+        }
+        throw new Error(`Cookie: "${COOKIE_BASE_URL}" não encontrado.`);
+    }
+    /**
+     * Retorna uma string com a URL dos serviços
+     * Caso contrário, retorna uma instância de Error
+     * @example "https://cloud-leaf.senior.com.br/t/senior.com.br/bridge/1.0/"
+     */
+    static getServicesURL() {
+        const cookie = AgroCookieUtils.getCookie(COOKIE_SERVICES_URL);
+        if (StringUtils.isNotEmpty(cookie)) {
+            return decodeURIComponent(cookie);
+        }
+        throw new Error(`Cookie: "${COOKIE_SERVICES_URL}" não encontrado.`);
+    }
+    /**
+     * Retorna uma string com o token de acesso atual
+     * Caso contrário, retorna uma instância de Error
+     */
+    static getCurrentAccessToken() {
+        const token = AgroPlatformUtils.getTokenField("access_token");
+        if (!token) {
+            console.info(`Cookie: "${COOKIE_TOKEN}" não encontrado.`);
+        }
+        return token || null;
+    }
+    /**
+     * Helper para extrair um campo do cookie de token.
+     */
+    static getTokenField(field) {
+        const cookie = AgroCookieUtils.getCookie(COOKIE_TOKEN);
+        if (!cookie) {
+            return undefined;
+        }
+        const obj = AgroCookieUtils.parseCookieToObject(cookie, true);
+        return obj[field];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agro-platform-utils.class.js","sourceRoot":"","sources":["../../../projects/angular-components/common/agro-platform-utils.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { AgroCookieUtils } from \"./agro-cookie-utils.class\";\r\nimport { AgroObjectUtils } from \"./agro-object-utils.class\";\r\nimport { StringUtils } from \"./agro-string-utils.class\";\r\n\r\n// Cookie name constants\r\nconst COOKIE_TOKEN = 'com.senior.token';\r\nconst COOKIE_BASE_URL = 'com.senior.base.url';\r\nconst COOKIE_SERVICES_URL = 'com.senior.services.url';\r\n\r\nexport {AgroPlatformUtils as APU, AgroPlatformUtils as PlatformUtils};\r\n\r\nexport class AgroPlatformUtils {\r\n    /**\r\n     * Retorna o tenant atual\r\n     * Caso contrário, retorna uma instância de Error\r\n     * @returns\r\n     */\r\n    static getCurrentTenant(): string {\r\n        const tenant = AgroPlatformUtils.getTokenField(\"tenantName\");\r\n        if (tenant) {\r\n            return tenant;\r\n        }\r\n        throw new Error(`Cookie: \"${COOKIE_TOKEN}\" não encontrado.`);\r\n    }\r\n\r\n    /**\r\n     * Retorna o locale do tenant atual\r\n     *\r\n     * @returns\r\n     */\r\n    static getCurrentTenantLocale(): string {\r\n        const locale = AgroPlatformUtils.getTokenField(\"locale\");\r\n        if (locale) {\r\n            return locale;\r\n        }\r\n        throw new Error(`'locale' não encontrado para o tenant atual.`);\r\n    }\r\n\r\n    /**\r\n     * @deprecated Use getCurrentTenantLocale()\r\n     * Mantido por compatibilidade retroativa.\r\n     */\r\n    static getCurrenTenantLocale(): string {\r\n        // legacy typo retained\r\n        return AgroPlatformUtils.getCurrentTenantLocale();\r\n    }\r\n\r\n    /**\r\n     * Retorna o nome completo do usuário logado\r\n     * Caso contrário, retorna uma instância de Error\r\n     * @returns string || null\r\n     */\r\n    static getCurrentUserName(): string | null {\r\n        const name = AgroPlatformUtils.getTokenField(\"fullName\");\r\n        return name || null;\r\n    }\r\n    /**\r\n     * Retorna o nome de usuário logado\r\n     * Ex: admin@tenant.com.br\r\n     * Caso contrário, retorna uma instância de Error\r\n     * @returns string || null\r\n     */\r\n    static getCurrentUserUsername(): string | null {\r\n        const username = AgroPlatformUtils.getTokenField(\"username\");\r\n        return username || null;\r\n    }\r\n\r\n    /**\r\n     * Retorna o e-mail do usuário logado\r\n     * Caso contrário, retorna uma instância de Error\r\n     * @returns string\r\n     */\r\n    static getCurrentUserEmail(): string | null {\r\n        const email = AgroPlatformUtils.getTokenField(\"email\");\r\n        if (!email) {\r\n            console.info(`Cookie: \"${COOKIE_TOKEN}\" não encontrado.`);\r\n        }\r\n        return email || null;\r\n    }\r\n\r\n    /**\r\n     * Retorna uma string com a baseURL atual\r\n     * Caso contrário, retorna uma instância de Error\r\n     * @example \"https://cloud-leaf.senior.com.br\" || \"https://platform.senior.com.br\"\r\n     */\r\n    static getBaseURL(): string {\r\n        const cookie = AgroCookieUtils.getCookie(COOKIE_BASE_URL);\r\n        if (cookie) {\r\n            return decodeURIComponent(cookie);\r\n        }\r\n        throw new Error(`Cookie: \"${COOKIE_BASE_URL}\" não encontrado.`);\r\n    }\r\n\r\n    /**\r\n     * Retorna uma string com a URL dos serviços\r\n     * Caso contrário, retorna uma instância de Error\r\n     * @example \"https://cloud-leaf.senior.com.br/t/senior.com.br/bridge/1.0/\"\r\n     */\r\n    static getServicesURL(): string {\r\n        const cookie = AgroCookieUtils.getCookie(COOKIE_SERVICES_URL);\r\n        if (StringUtils.isNotEmpty(cookie)) {\r\n            return decodeURIComponent(cookie!);\r\n        }\r\n        throw new Error(`Cookie: \"${COOKIE_SERVICES_URL}\" não encontrado.`);\r\n    }\r\n\r\n    /**\r\n     * Retorna uma string com o token de acesso atual\r\n     * Caso contrário, retorna uma instância de Error\r\n     */\r\n    static getCurrentAccessToken(): string | null {\r\n        const token = AgroPlatformUtils.getTokenField(\"access_token\");\r\n        if (!token) {\r\n            console.info(`Cookie: \"${COOKIE_TOKEN}\" não encontrado.`);\r\n        }\r\n        return token || null;\r\n    }\r\n\r\n    /**\r\n     * Helper para extrair um campo do cookie de token.\r\n     */\r\n    private static getTokenField(field: string): string | undefined {\r\n        const cookie = AgroCookieUtils.getCookie(COOKIE_TOKEN);\r\n        if (!cookie) {\r\n            return undefined;\r\n        }\r\n        const obj = AgroCookieUtils.parseCookieToObject(cookie, true);\r\n        return obj[field];\r\n    }\r\n}\r\n"]}