@senior-agronegocio/angular-components 0.0.9883 → 1.0.0

package/esm2022/common/agro-logics.class.mjs

@@ -0,0 +1,54 @@
+import { AGRO_NUMBERS } from '../enums';
+export class AgroLogics {
+    // 🔹 Constantes locais
+    static FAHRENHEIT_OFFSET = 32;
+    static FAHRENHEIT_NUMERATOR = 9;
+    static FAHRENHEIT_DENOMINATOR = 5;
+    static KELVIN_OFFSET = 273.15;
+    static PERCENT = 100;
+    /**
+     * Agrupa o conjunto de dados pelos campos de entidade fornecidos e calcula
+     * a distribuição de probabilidade (frequência e porcentagem).
+     *
+     * @param data - Array de objetos a serem analisados
+     * @param keys - Chaves ou caminhos aninhados para agrupar (ex: ["entity1", "entity2"])
+     * @returns Array de estatísticas agrupadas ordenadas por samplingSuccess (decrescente)
+     */
+    static entityDistributionStats(data, keys) {
+        const total = data.length;
+        const map = new Map();
+        const resolvePath = (source, path) => {
+            const parts = path.split('.');
+            let value = source;
+            for (const p of parts) {
+                if (value == null) {
+                    return undefined;
+                }
+                value = value[p];
+            }
+            return value;
+        };
+        for (const item of data) {
+            const keyValues = keys.map((k) => resolvePath(item, k));
+            const uniqueKey = JSON.stringify(keyValues);
+            if (!map.has(uniqueKey)) {
+                const groupedData = {};
+                for (const k of keys) {
+                    const rootName = k.toString().split('.')[0];
+                    groupedData[rootName] = resolvePath(item, k);
+                }
+                map.set(uniqueKey, { data: groupedData, count: 0 });
+            }
+            const entry = map.get(uniqueKey);
+            entry.count += AGRO_NUMBERS.ONE;
+        }
+        const result = Array.from(map.values()).map((entry) => ({
+            data: entry.data,
+            samplingQuantity: entry.count,
+            samplingSuccess: Math.round((entry.count / total) * this.PERCENT),
+        }));
+        result.sort((a, b) => b.samplingSuccess - a.samplingSuccess);
+        return result;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,60 @@
+import { AgroStringUtils } from "./agro-string-utils.class";
+import { AGRO_NUMBERS } from "../enums";
+export class AgroNameUtils {
+    /**
+     * Abrevia o último sobrenome, mantendo o primeiro nome completo.
+     * @param fullName valor completo do nome (Ex: Tiago Batista Corrêa)
+     * @returns nome abreviado (Ex: Tiago C.)
+     */
+    static abbreviateName(fullName) {
+        if (AgroStringUtils.isInvalid(fullName)) {
+            return null;
+        }
+        const parts = fullName.trim().split(/\s+/);
+        if (parts.length < AGRO_NUMBERS.TWO) {
+            return fullName; // Retorna o nome original se não puder ser abreviado
+        }
+        const firstName = parts[0]; // Primeiro nome completo
+        const lastName = parts[parts.length - 1]; // Último sobrenome
+        // Retorna o nome abreviado
+        return `${firstName} ${lastName.charAt(0)}.`;
+    }
+    /**
+     * Abrevia todos os sobrenomes, mantendo o primeiro nome completo.
+     *
+     * @param fullName O nome completo. (Ex: Tiago Batista Corrêa)
+     * @returns O nome com os sobrenomes abreviados. (Ex: Tiago B. C.)
+     */
+    static abbreviateAllLastNames(fullName) {
+        if (AgroStringUtils.isInvalid(fullName)) {
+            return null;
+        }
+        const parts = fullName.trim().split(/\s+/);
+        if (parts.length < AGRO_NUMBERS.TWO) {
+            return fullName;
+        }
+        const firstName = parts[0];
+        const abbreviatedLastNames = parts
+            .slice(1)
+            .map((name) => `${name.charAt(0)}.`)
+            .join(" ");
+        return `${firstName} ${abbreviatedLastNames}`;
+    }
+    /**
+     * Retorna as iniciais do nome completo.
+     *
+     * @param fullName O nome completo. (Ex: Tiago Batista Corrêa)
+     * @returns Uma string contendo as iniciais do nome. (Ex: TBC)
+     */
+    static getInitials(fullName) {
+        if (AgroStringUtils.isInvalid(fullName)) {
+            return null;
+        }
+        return fullName
+            .trim()
+            .split(/\s+/)
+            .map((name) => name.charAt(0).toUpperCase())
+            .join("");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,129 @@
+/**
+ * Classe de utilitários para operações com números.
+ */
+import { AGRO_NUMBERS } from "../enums";
+export class AgroNumberUtils {
+    /**
+     * Verifica se um número é nulo ou indefinido.
+     * @param num - O número a ser verificado.
+     * @returns True se o número for nulo ou indefinido, false caso contrário.
+     */
+    static isNullOrUndefined(num) {
+        return num === null || num === undefined;
+    }
+    /**
+     * Verifica se um número não é nulo e não é indefinido.
+     * @param num - O número a ser verificado.
+     * @returns True se o número não for nulo e não for indefinido, false caso contrário.
+     */
+    static isNotNullOrUndefined(num) {
+        return !AgroNumberUtils.isNullOrUndefined(num);
+    }
+    /**
+     * Verifica se um número é par.
+     *
+     * @param value O número a ser verificado.
+     * @returns True se for par, false caso contrário.
+     */
+    static isEven(value) {
+        return value % AGRO_NUMBERS.TWO === AGRO_NUMBERS.ZERO;
+    }
+    /**
+     * Verifica se um número é ímpar.
+     *
+     * @param value O número a ser verificado.
+     * @returns True se for ímpar, false caso contrário.
+     */
+    static isOdd(value) {
+        return value % AGRO_NUMBERS.TWO !== AGRO_NUMBERS.ZERO;
+    }
+    /**
+     * Calcula a porcentagem de um valor em relação a um total.
+     *
+     * @param partial O valor parcial.
+     * @param total O valor total.
+     * @returns A porcentagem calculada.
+     */
+    static percentage(partial, total) {
+        if (total === AGRO_NUMBERS.ZERO) {
+            throw new Error("O total não pode ser zero.");
+        }
+        return (partial / total) * AGRO_NUMBERS.ONE_HUNDRED;
+    }
+    /**
+     * Formata um número para o formato monetário.
+     *
+     * @param value O número a ser formatado.
+     * @param currency O símbolo da moeda (padrão: "BRL").
+     * @param locale O código da localidade (padrão: "pt-BR").
+     * @returns Uma string no formato monetário.
+     */
+    static toCurrency(value, currency = "BRL", locale = "pt-BR") {
+        return new Intl.NumberFormat(locale, {
+            style: "currency",
+            currency: currency,
+        }).format(value);
+    }
+    /**
+     * Gera um número aleatório no intervalo especificado.
+     *
+     * @param min O valor mínimo (inclusivo).
+     * @param max O valor máximo (exclusivo).
+     * @returns Um número aleatório no intervalo.
+     */
+    static randomInRange(min, max) {
+        if (max <= min) {
+            throw new Error("O valor máximo deve ser maior que o mínimo.");
+        }
+        return Math.random() * (max - min) + min;
+    }
+    /**
+     * Verifica se um número é primo.
+     *
+     * @param value O número a ser verificado.
+     * @returns True se for primo, false caso contrário.
+     */
+    static isPrime(value) {
+        if (value <= AGRO_NUMBERS.ONE) {
+            return false;
+        }
+        for (let i = AGRO_NUMBERS.TWO; i <= Math.sqrt(value); i++) {
+            if (value % i === AGRO_NUMBERS.ZERO) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Arredonda um número para `n` casas decimais.
+     *
+     * @param value O número a ser arredondado.
+     * @param decimals O número de casas decimais (padrão: 2).
+     * @returns O número arredondado.
+     */
+    static roundTo(value, decimals = AGRO_NUMBERS.TWO) {
+        if (decimals < AGRO_NUMBERS.ZERO) {
+            throw new Error("O número de casas decimais não pode ser negativo.");
+        }
+        const factor = Math.pow(AGRO_NUMBERS.TEN, decimals);
+        return Math.round(value * factor) / factor;
+    }
+    /**
+     * Pega apenas números, convertendo strings para números e retornarndo apenas o maior inteiro encontrado.
+     * @param value - O valor a ser processado.
+     * @returns O maior número inteiro encontrado ou 0 se nenhum número for encontrado.
+     */
+    static getNearInteger(value) {
+        if (typeof value === "number") {
+            return Math.floor(value);
+        }
+        if (typeof value === "string") {
+            const numbers = value.match(/\d+/g);
+            if (numbers && numbers.length > 0) {
+                return Math.max(...numbers.map(Number));
+            }
+        }
+        return 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agro-number-utils.class.js","sourceRoot":"","sources":["../../../projects/angular-components/common/agro-number-utils.class.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Classe de utilitários para operações com números.\r\n */\r\n\r\nimport { AGRO_NUMBERS } from \"../enums\";\r\n\r\nexport class AgroNumberUtils {\r\n    /**\r\n     * Verifica se um número é nulo ou indefinido.\r\n     * @param num - O número a ser verificado.\r\n     * @returns True se o número for nulo ou indefinido, false caso contrário.\r\n     */\r\n    static isNullOrUndefined(num: any): boolean {\r\n        return num === null || num === undefined;\r\n    }\r\n\r\n    /**\r\n     * Verifica se um número não é nulo e não é indefinido.\r\n     * @param num - O número a ser verificado.\r\n     * @returns True se o número não for nulo e não for indefinido, false caso contrário.\r\n     */\r\n    static isNotNullOrUndefined(num: any): boolean {\r\n        return !AgroNumberUtils.isNullOrUndefined(num);\r\n    }\r\n\r\n    /**\r\n     * Verifica se um número é par.\r\n     *\r\n     * @param value O número a ser verificado.\r\n     * @returns True se for par, false caso contrário.\r\n     */\r\n    static isEven(value: number): boolean {\r\n    return value % AGRO_NUMBERS.TWO === AGRO_NUMBERS.ZERO;\r\n    }\r\n\r\n    /**\r\n     * Verifica se um número é ímpar.\r\n     *\r\n     * @param value O número a ser verificado.\r\n     * @returns True se for ímpar, false caso contrário.\r\n     */\r\n    static isOdd(value: number): boolean {\r\n    return value % AGRO_NUMBERS.TWO !== AGRO_NUMBERS.ZERO;\r\n    }\r\n\r\n    /**\r\n     * Calcula a porcentagem de um valor em relação a um total.\r\n     *\r\n     * @param partial O valor parcial.\r\n     * @param total O valor total.\r\n     * @returns A porcentagem calculada.\r\n     */\r\n    static percentage(partial: number, total: number): number {\r\n        if (total === AGRO_NUMBERS.ZERO) {\r\n            throw new Error(\"O total não pode ser zero.\");\r\n        }\r\n    return (partial / total) * AGRO_NUMBERS.ONE_HUNDRED;\r\n    }\r\n\r\n    /**\r\n     * Formata um número para o formato monetário.\r\n     *\r\n     * @param value O número a ser formatado.\r\n     * @param currency O símbolo da moeda (padrão: \"BRL\").\r\n     * @param locale O código da localidade (padrão: \"pt-BR\").\r\n     * @returns Uma string no formato monetário.\r\n     */\r\n    static toCurrency(value: number, currency: string = \"BRL\", locale: string = \"pt-BR\"): string {\r\n        return new Intl.NumberFormat(locale, {\r\n            style: \"currency\",\r\n            currency: currency,\r\n        }).format(value);\r\n    }\r\n\r\n    /**\r\n     * Gera um número aleatório no intervalo especificado.\r\n     *\r\n     * @param min O valor mínimo (inclusivo).\r\n     * @param max O valor máximo (exclusivo).\r\n     * @returns Um número aleatório no intervalo.\r\n     */\r\n    static randomInRange(min: number, max: number): number {\r\n        if (max <= min) {\r\n            throw new Error(\"O valor máximo deve ser maior que o mínimo.\");\r\n        }\r\n        return Math.random() * (max - min) + min;\r\n    }\r\n\r\n    /**\r\n     * Verifica se um número é primo.\r\n     *\r\n     * @param value O número a ser verificado.\r\n     * @returns True se for primo, false caso contrário.\r\n     */\r\n    static isPrime(value: number): boolean {\r\n        if (value <= AGRO_NUMBERS.ONE) {\r\n            return false;\r\n        }\r\n        for (let i = AGRO_NUMBERS.TWO; i <= Math.sqrt(value); i++) {\r\n            if (value % i === AGRO_NUMBERS.ZERO) {\r\n                return false;\r\n            }\r\n        }\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * Arredonda um número para `n` casas decimais.\r\n     *\r\n     * @param value O número a ser arredondado.\r\n     * @param decimals O número de casas decimais (padrão: 2).\r\n     * @returns O número arredondado.\r\n     */\r\n    static roundTo(value: number, decimals: number = AGRO_NUMBERS.TWO): number {\r\n        if (decimals < AGRO_NUMBERS.ZERO) {\r\n            throw new Error(\"O número de casas decimais não pode ser negativo.\");\r\n        }\r\n        const factor = Math.pow(AGRO_NUMBERS.TEN, decimals);\r\n        return Math.round(value * factor) / factor;\r\n    }\r\n\r\n\r\n    /**\r\n     * Pega apenas números, convertendo strings para números e retornarndo apenas o maior inteiro encontrado.\r\n     * @param value - O valor a ser processado.\r\n     * @returns O maior número inteiro encontrado ou 0 se nenhum número for encontrado.\r\n     */\r\n    static getNearInteger(value: any): number {\r\n        if (typeof value === \"number\") {\r\n            return Math.floor(value);\r\n        }\r\n\r\n        if (typeof value === \"string\") {\r\n            const numbers = value.match(/\\d+/g);\r\n            if (numbers && numbers.length > 0) {\r\n                return Math.max(...numbers.map(Number));\r\n            }\r\n        }\r\n\r\n        return 0;\r\n    }\r\n}\r\n"]}

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

@@ -0,0 +1,34 @@
+import { AgroStringUtils } from "./agro-string-utils.class";
+export class AgroObjectStringifier {
+    /**
+     * Formata um objeto concatenando valores segundo as chaves e pipes informados.
+     *
+     * @param separator Separador entre os valores (ex: "-")
+     * @param fields Campos a extrair. Podem conter subpropriedades ("propriedade.subPropriedade") e pipes ("propriedade|nomeDaPipe:arg1:arg2")
+     * @param obj Objeto origem
+     */
+    static formatObject(separator, fields, obj, usePipes) {
+        function mapField(field) {
+            const value = AgroObjectStringifier.resolvePath(obj, field);
+            if (usePipes?.hasOwnProperty(field)) {
+                if (AgroStringUtils.isString(usePipes[field])) {
+                    return usePipes[field].toString();
+                }
+                return usePipes[field].transform(value);
+            }
+            return value ?? "";
+        }
+        function filterValid(v) {
+            return typeof v === "number" || AgroStringUtils.isValid(v);
+        }
+        return fields.map(mapField).filter(filterValid).join(` ${separator} `);
+    }
+    /** Resolve um caminho tipo "empresa.cargo" dentro de um objeto */
+    static resolvePath(obj, path) {
+        function reducer(acc, key) {
+            return acc?.[key];
+        }
+        return path.split(".").reduce(reducer, obj);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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