@senior-agronegocio/angular-components 0.0.49

package/enums/agro-string-masks.enum.d.ts

@@ -0,0 +1,10 @@
+export declare enum AgroStringMasks {
+    CNPJ = "99.999.999/9999-99",
+    CPF = "999.999.999-99",
+    CEP = "99999-999",
+    CELLPHONE = "(99) 99999-9999",
+    PHONE = "(99) 9999-9999",
+    DATE = "99/99/9999",
+    TIME = "99:99",
+    DATETIME = "99/99/9999 99:99"
+}

package/enums/date-comparison-type.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum DateComparisonType {
+    greatherThan = "greatherThan",
+    lessThan = "lessThan"
+}

package/enums/http-codes.enum.d.ts

@@ -0,0 +1,64 @@
+export declare enum HttpCodes {
+    Continue = 100,
+    SwitchingProtocols = 101,
+    Processing = 102,
+    EarlyHints = 103,
+    OK = 200,
+    Created = 201,
+    Accepted = 202,
+    NonAuthoritativeInformation = 203,
+    NoContent = 204,
+    ResetContent = 205,
+    PartialContent = 206,
+    MultiStatus = 207,
+    AlreadyReported = 208,
+    IMUsed = 226,
+    MultipleChoices = 300,
+    MovedPermanently = 301,
+    Found = 302,
+    SeeOther = 303,
+    NotModified = 304,
+    UseProxy = 305,
+    TemporaryRedirect = 307,
+    PermanentRedirect = 308,
+    BadRequest = 400,
+    Unauthorized = 401,
+    PaymentRequired = 402,
+    Forbidden = 403,
+    NotFound = 404,
+    MethodNotAllowed = 405,
+    NotAcceptable = 406,
+    ProxyAuthenticationRequired = 407,
+    RequestTimeout = 408,
+    Conflict = 409,
+    Gone = 410,
+    LengthRequired = 411,
+    PreconditionFailed = 412,
+    PayloadTooLarge = 413,
+    URITooLong = 414,
+    UnsupportedMediaType = 415,
+    RangeNotSatisfiable = 416,
+    ExpectationFailed = 417,
+    ImATeapot = 418,
+    MisdirectedRequest = 421,
+    UnprocessableEntity = 422,
+    Locked = 423,
+    FailedDependency = 424,
+    TooEarly = 425,
+    UpgradeRequired = 426,
+    PreconditionRequired = 428,
+    TooManyRequests = 429,
+    RequestHeaderFieldsTooLarge = 431,
+    UnavailableForLegalReasons = 451,
+    InternalServerError = 500,
+    NotImplemented = 501,
+    BadGateway = 502,
+    ServiceUnavailable = 503,
+    GatewayTimeout = 504,
+    HTTPVersionNotSupported = 505,
+    VariantAlsoNegotiates = 506,
+    InsufficientStorage = 507,
+    LoopDetected = 508,
+    NotExtended = 510,
+    NetworkAuthenticationRequired = 511
+}

package/enums/index.d.ts

@@ -0,0 +1,6 @@
+export { AgroEntityStatus } from './agro-entity-status.enum';
+export { AGRO_NUMBERS, NUMBERS } from './agro-numbers.enum';
+export { AgroStringMasks } from './agro-string-masks.enum';
+export { DateComparisonType } from './date-comparison-type.enum';
+export { HttpCodes } from './http-codes.enum';
+export { NumberComparisonType } from './number-comparison-type.enum';

package/enums/number-comparison-type.enum.d.ts

@@ -0,0 +1,8 @@
+export declare enum NumberComparisonType {
+    EQUALS = "EQUALS",
+    NOT_EQUALS = "NOT_EQUALS",
+    LESS_THAN = "LESS_THAN",
+    LESS_THAN_OR_EQUAL = "LESS_THAN_OR_EQUAL",
+    GREATER_THAN = "GREATER_THAN",
+    GREATER_THAN_OR_EQUAL = "GREATER_THAN_OR_EQUAL"
+}

package/esm2015/agro-angular-components.module.js

@@ -0,0 +1,22 @@
+var AgroAngularComponentsModule_1;
+import { __decorate } from "tslib";
+import { NgModule, InjectionToken } from "@angular/core";
+export const HostProjectConfigsInjectionToken = new InjectionToken("hostProjectConfigs");
+let AgroAngularComponentsModule = AgroAngularComponentsModule_1 = class AgroAngularComponentsModule {
+    static forRoot(config) {
+        return {
+            ngModule: AgroAngularComponentsModule_1,
+            providers: [
+                {
+                    provide: HostProjectConfigsInjectionToken,
+                    useValue: config
+                }
+            ]
+        };
+    }
+};
+AgroAngularComponentsModule = AgroAngularComponentsModule_1 = __decorate([
+    NgModule({})
+], AgroAngularComponentsModule);
+export { AgroAngularComponentsModule };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdyby1hbmd1bGFyLWNvbXBvbmVudHMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQHNlbmlvci1hZ3JvbmVnb2Npby9hbmd1bGFyLWNvbXBvbmVudHMvIiwic291cmNlcyI6WyJhZ3JvLWFuZ3VsYXItY29tcG9uZW50cy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxPQUFPLEVBRUgsUUFBUSxFQUNSLGNBQWMsRUFDakIsTUFBTSxlQUFlLENBQUM7QUFFdkIsTUFBTSxDQUFDLE1BQU0sZ0NBQWdDLEdBQUcsSUFBSSxjQUFjLENBQXFCLG9CQUFvQixDQUFDLENBQUM7QUFTN0csSUFBYSwyQkFBMkIsbUNBQXhDLE1BQWEsMkJBQTJCO0lBQ3BDLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBMEI7UUFDckMsT0FBTztZQUNILFFBQVEsRUFBRSw2QkFBMkI7WUFDckMsU0FBUyxFQUFFO2dCQUNQO29CQUNJLE9BQU8sRUFBRSxnQ0FBZ0M7b0JBQ3pDLFFBQVEsRUFBRSxNQUFNO2lCQUNuQjthQUNKO1NBQ0osQ0FBQztJQUNOLENBQUM7Q0FDSixDQUFBO0FBWlksMkJBQTJCO0lBRnZDLFFBQVEsQ0FBQyxFQUNULENBQUM7R0FDVywyQkFBMkIsQ0FZdkM7U0FaWSwyQkFBMkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xyXG4gICAgTW9kdWxlV2l0aFByb3ZpZGVycyxcclxuICAgIE5nTW9kdWxlLFxyXG4gICAgSW5qZWN0aW9uVG9rZW5cclxufSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5cclxuZXhwb3J0IGNvbnN0IEhvc3RQcm9qZWN0Q29uZmlnc0luamVjdGlvblRva2VuID0gbmV3IEluamVjdGlvblRva2VuPEhvc3RQcm9qZWN0Q29uZmlncz4oXCJob3N0UHJvamVjdENvbmZpZ3NcIik7XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEhvc3RQcm9qZWN0Q29uZmlncyB7XHJcbiAgICBkb21haW46IHN0cmluZztcclxuICAgIHNlcnZpY2U6IHN0cmluZztcclxufVxyXG5cclxuQE5nTW9kdWxlKHtcclxufSlcclxuZXhwb3J0IGNsYXNzIEFncm9Bbmd1bGFyQ29tcG9uZW50c01vZHVsZSB7XHJcbiAgICBzdGF0aWMgZm9yUm9vdChjb25maWc6IEhvc3RQcm9qZWN0Q29uZmlncyk6IE1vZHVsZVdpdGhQcm92aWRlcnM8QWdyb0FuZ3VsYXJDb21wb25lbnRzTW9kdWxlPiB7XHJcbiAgICAgICAgcmV0dXJuIHtcclxuICAgICAgICAgICAgbmdNb2R1bGU6IEFncm9Bbmd1bGFyQ29tcG9uZW50c01vZHVsZSxcclxuICAgICAgICAgICAgcHJvdmlkZXJzOiBbXHJcbiAgICAgICAgICAgICAgICB7XHJcbiAgICAgICAgICAgICAgICAgICAgcHJvdmlkZTogSG9zdFByb2plY3RDb25maWdzSW5qZWN0aW9uVG9rZW4sXHJcbiAgICAgICAgICAgICAgICAgICAgdXNlVmFsdWU6IGNvbmZpZ1xyXG4gICAgICAgICAgICAgICAgfVxyXG4gICAgICAgICAgICBdXHJcbiAgICAgICAgfTtcclxuICAgIH1cclxufVxyXG4iXX0=

package/esm2015/common/agro-array-utils.class.js

@@ -0,0 +1,56 @@
+/**
+ * Classe com funções úteis para Arrays.
+ */
+export class AgroArrayUtils {
+    /**
+     * Verifica se o valor informado é um array.
+     */
+    static isArray(value) {
+        return Array.isArray(value);
+    }
+    /**
+     * Remove um item de um array.
+     * @param array Array de onde o item será removido.
+     * @param item Item a ser removido.
+     */
+    static removeItem(array, item) {
+        const index = array.indexOf(item);
+        if (index !== -1) {
+            array.splice(index, 1);
+        }
+    }
+    /**
+     * Remove um item de um array por índice.
+     * @param array Array de onde o item será removido.
+     * @param index Índice do item a ser removido.
+     */
+    static removeItemByIndex(array, index) {
+        array.splice(index, 1);
+    }
+    /**
+     * Remove todos os itens de um array.
+     * @param array Array de onde os itens serão removidos.
+     */
+    static removeAllItems(array) {
+        array.splice(0, array.length);
+    }
+    /**
+     * Verifica se um array é vazio.
+     * @param array Array a ser verificado.
+     */
+    static isEmpty(array) {
+        return AgroArrayUtils.isArray(array) && array.length === 0;
+    }
+    /**
+     * Localiza um item em um array de objetos de acordo com a propriedade e valor informados.
+     */
+    static findItemByProperty(array, property, value) {
+        for (const item of array) {
+            if (item[property] === value) {
+                return item;
+            }
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/common/agro-cookie-utils.class.js

@@ -0,0 +1,31 @@
+export { AgroCookieUtils as ACU, AgroCookieUtils as CookieUtils };
+export class AgroCookieUtils {
+    static getCookie(name, parseURIValue = false) {
+        const cookieValue = document.cookie.split(';')
+            .map(cookie => cookie.trim())
+            .find(cookie => cookie.startsWith(name));
+        let result = cookieValue === null || cookieValue === void 0 ? void 0 : cookieValue.split('=')[1];
+        if (parseURIValue && result) {
+            result = decodeURIComponent(result);
+        }
+        return result;
+    }
+    static parseCookieToObject(cookieString, parseURIString = false) {
+        const cookieObject = {};
+        if (parseURIString) {
+            cookieString = decodeURIComponent(cookieString);
+        }
+        cookieString.split(';').forEach(cookie => {
+            const [key, value] = cookie.split('=').map(c => c.trim());
+            cookieObject[key] = value;
+        });
+        return cookieObject;
+    }
+    setCookie(name, value, days) {
+        const date = new Date();
+        date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+        const expires = 'expires=' + date.toUTCString();
+        document.cookie = name + '=' + value + ';' + expires + ';path=/';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/common/agro-date-utils.class.js

@@ -0,0 +1,117 @@
+import { AGRO_NUMBERS } from '../enums';
+export class AgroDateUtils {
+    /**
+     * Verifica se uma data é nula ou indefinida.
+     * @param date - A data a ser verificada.
+     * @returns True se a data for nula ou indefinida, false caso contrário.
+     */
+    static isNullOrUndefined(date) {
+        return date === null || date === undefined;
+    }
+    /**
+     * Verifica se uma data não é nula e não é indefinida.
+     * @param date - A data a ser verificada.
+     * @returns True se a data não for nula e não for indefinida, false caso contrário.
+     */
+    static isNotNullOrUndefined(date) {
+        return !AgroDateUtils.isNullOrUndefined(date);
+    }
+    /**
+     * Verifica se uma data é válida.
+     * @param date - A data a ser verificada.
+     * @returns True se a data for válida, false caso contrário.
+     */
+    static isValid(date) {
+        return !isNaN(Date.parse(date));
+    }
+    /**
+     * Verifica se uma data é inválida.
+     * @param date - A data a ser verificada.
+     * @returns True se a data for inválida, false caso contrário.
+     */
+    static isInvalid(date) {
+        return !AgroDateUtils.isValid(date);
+    }
+    /**
+     * Verifica se uma data é antes de outra data.
+     * @param date - A data a ser verificada.
+     * @param otherDate - A outra data a ser comparada.
+     * @returns True se a data for antes da outra data, false caso contrário.
+     */
+    static isBefore(date, otherDate) {
+        return date < otherDate;
+    }
+    /**
+     * Verifica se uma data é depois de outra data.
+     * @param date - A data a ser verificada.
+     * @param otherDate - A outra data a ser comparada.
+     * @returns True se a data for depois da outra data, false caso contrário.
+     */
+    static isAfter(date, otherDate) {
+        return date > otherDate;
+    }
+    /**
+     * Verifica se uma data é igual a outra data.
+     * @param date - A data a ser verificada.
+     * @param otherDate - A outra data a ser comparada.
+     * @returns True se a data for igual a outra data, false caso contrário.
+     */
+    static isEqual(date, otherDate) {
+        return date.getTime() === otherDate.getTime();
+    }
+    /**
+     * Verifica se uma data é menor ou igual a outra data.
+     * @param date - A data a ser verificada.
+     * @param otherDate - A outra data a ser comparada.
+     * @returns True se a data for menor ou igual a outra data, false caso contrário.
+     */
+    static isLessOrEqual(date, otherDate) {
+        return date <= otherDate;
+    }
+    /**
+     * Verifica se uma data é maior ou igual a outra data.
+     * @param date - A data a ser verificada.
+     * @param otherDate - A outra data a ser comparada.
+     * @returns True se a data for maior ou igual a outra data, false caso contrário.
+     */
+    static isGreaterOrEqual(date, otherDate) {
+        return date >= otherDate;
+    }
+    /**
+     * Verifica se uma data é menor que outra data.
+     * @param date - A data a ser verificada.
+     * @param otherDate - A outra data a ser comparada.
+     * @returns True se a data for menor que outra data, false caso contrário.
+     */
+    static isLess(date, otherDate) {
+        return date < otherDate;
+    }
+    /**
+     * Verifica se uma data é maior que outra data.
+     * @param date - A data a ser verificada.
+     * @param otherDate - A outra data a ser comparada.
+     * @returns True se a data for maior que outra data, false caso contrário.
+     */
+    static isGreater(date, otherDate) {
+        return date > otherDate;
+    }
+    /**
+     * Retorna a data formatada conforme o formato especificado.
+     * @param date
+     * @param format
+     * @returns
+     */
+    static formatDate(date, format = 'DD/MM/YYYY') {
+        const moment = require('moment');
+        return moment(date).utc().format(format);
+    }
+    /**
+     * Retorna uma string com o número informado adicionando um 0 à esquerda, caso o número seja menor que 10.
+     * @param value
+     * @returns
+     */
+    static padZero(value) {
+        return value < AGRO_NUMBERS.TEN ? '0' + value : value.toString();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agro-date-utils.class.js","sourceRoot":"ng://@senior-agronegocio/angular-components/","sources":["common/agro-date-utils.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAExC,MAAM,OAAO,aAAa;IACtB;;;;OAIG;IACI,MAAM,CAAC,iBAAiB,CAAC,IAA6B;QACzD,OAAO,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,SAAS,CAAC;IAC/C,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,oBAAoB,CAAC,IAA6B;QAC5D,OAAO,CAAC,aAAa,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAClD,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,OAAO,CAAC,IAAY;QAC9B,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;IACpC,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,SAAS,CAAC,IAAY;QAChC,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,QAAQ,CAAC,IAAU,EAAE,SAAe;QAC9C,OAAO,IAAI,GAAG,SAAS,CAAC;IAC5B,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,OAAO,CAAC,IAAU,EAAE,SAAe;QAC7C,OAAO,IAAI,GAAG,SAAS,CAAC;IAC5B,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,OAAO,CAAC,IAAU,EAAE,SAAe;QAC7C,OAAO,IAAI,CAAC,OAAO,EAAE,KAAK,SAAS,CAAC,OAAO,EAAE,CAAC;IAClD,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,aAAa,CAAC,IAAU,EAAE,SAAe;QACnD,OAAO,IAAI,IAAI,SAAS,CAAC;IAC7B,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,gBAAgB,CAAC,IAAU,EAAE,SAAe;QACtD,OAAO,IAAI,IAAI,SAAS,CAAC;IAC7B,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,MAAM,CAAC,IAAU,EAAE,SAAe;QAC5C,OAAO,IAAI,GAAG,SAAS,CAAC;IAC5B,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,SAAS,CAAC,IAAU,EAAE,SAAe;QAC/C,OAAO,IAAI,GAAG,SAAS,CAAC;IAC5B,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,IAAU,EAAE,SAAiB,YAAY;QACvD,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;QACjC,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC7C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,OAAO,CAAC,KAAa;QACxB,OAAO,KAAK,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;IACrE,CAAC;CACJ","sourcesContent":["import { AGRO_NUMBERS } from '../enums';\r\n\r\nexport class AgroDateUtils {\r\n    /**\r\n     * Verifica se uma data é nula ou indefinida.\r\n     * @param date - A data a ser verificada.\r\n     * @returns True se a data for nula ou indefinida, false caso contrário.\r\n     */\r\n    public static isNullOrUndefined(date: Date | null | undefined): boolean {\r\n        return date === null || date === undefined;\r\n    }\r\n\r\n    /**\r\n     * Verifica se uma data não é nula e não é indefinida.\r\n     * @param date - A data a ser verificada.\r\n     * @returns True se a data não for nula e não for indefinida, false caso contrário.\r\n     */\r\n    public static isNotNullOrUndefined(date: Date | null | undefined): boolean {\r\n        return !AgroDateUtils.isNullOrUndefined(date);\r\n    }\r\n\r\n    /**\r\n     * Verifica se uma data é válida.\r\n     * @param date - A data a ser verificada.\r\n     * @returns True se a data for válida, false caso contrário.\r\n     */\r\n    public static isValid(date: string): boolean {\r\n        return !isNaN(Date.parse(date));\r\n    }\r\n\r\n    /**\r\n     * Verifica se uma data é inválida.\r\n     * @param date - A data a ser verificada.\r\n     * @returns True se a data for inválida, false caso contrário.\r\n     */\r\n    public static isInvalid(date: string): boolean {\r\n        return !AgroDateUtils.isValid(date);\r\n    }\r\n\r\n    /**\r\n     * Verifica se uma data é antes de outra data.\r\n     * @param date - A data a ser verificada.\r\n     * @param otherDate - A outra data a ser comparada.\r\n     * @returns True se a data for antes da outra data, false caso contrário.\r\n     */\r\n    public static isBefore(date: Date, otherDate: Date): boolean {\r\n        return date < otherDate;\r\n    }\r\n\r\n    /**\r\n     * Verifica se uma data é depois de outra data.\r\n     * @param date - A data a ser verificada.\r\n     * @param otherDate - A outra data a ser comparada.\r\n     * @returns True se a data for depois da outra data, false caso contrário.\r\n     */\r\n    public static isAfter(date: Date, otherDate: Date): boolean {\r\n        return date > otherDate;\r\n    }\r\n\r\n    /**\r\n     * Verifica se uma data é igual a outra data.\r\n     * @param date - A data a ser verificada.\r\n     * @param otherDate - A outra data a ser comparada.\r\n     * @returns True se a data for igual a outra data, false caso contrário.\r\n     */\r\n    public static isEqual(date: Date, otherDate: Date): boolean {\r\n        return date.getTime() === otherDate.getTime();\r\n    }\r\n\r\n    /**\r\n     * Verifica se uma data é menor ou igual a outra data.\r\n     * @param date - A data a ser verificada.\r\n     * @param otherDate - A outra data a ser comparada.\r\n     * @returns True se a data for menor ou igual a outra data, false caso contrário.\r\n     */\r\n    public static isLessOrEqual(date: Date, otherDate: Date): boolean {\r\n        return date <= otherDate;\r\n    }\r\n\r\n    /**\r\n     * Verifica se uma data é maior ou igual a outra data.\r\n     * @param date - A data a ser verificada.\r\n     * @param otherDate - A outra data a ser comparada.\r\n     * @returns True se a data for maior ou igual a outra data, false caso contrário.\r\n     */\r\n    public static isGreaterOrEqual(date: Date, otherDate: Date): boolean {\r\n        return date >= otherDate;\r\n    }\r\n\r\n    /**\r\n     * Verifica se uma data é menor que outra data.\r\n     * @param date - A data a ser verificada.\r\n     * @param otherDate - A outra data a ser comparada.\r\n     * @returns True se a data for menor que outra data, false caso contrário.\r\n     */\r\n    public static isLess(date: Date, otherDate: Date): boolean {\r\n        return date < otherDate;\r\n    }\r\n\r\n    /**\r\n     * Verifica se uma data é maior que outra data.\r\n     * @param date - A data a ser verificada.\r\n     * @param otherDate - A outra data a ser comparada.\r\n     * @returns True se a data for maior que outra data, false caso contrário.\r\n     */\r\n    public static isGreater(date: Date, otherDate: Date): boolean {\r\n        return date > otherDate;\r\n    }\r\n\r\n    /**\r\n     * Retorna a data formatada conforme o formato especificado.\r\n     * @param date\r\n     * @param format\r\n     * @returns\r\n     */\r\n    static formatDate(date: Date, format: string = 'DD/MM/YYYY'): string {\r\n        const moment = require('moment');\r\n        return moment(date).utc().format(format);\r\n    }\r\n\r\n    /**\r\n     * Retorna uma string com o número informado adicionando um 0 à esquerda, caso o número seja menor que 10.\r\n     * @param value\r\n     * @returns\r\n     */\r\n    static padZero(value: number): string {\r\n        return value < AGRO_NUMBERS.TEN ? '0' + value : value.toString();\r\n    }\r\n}"]}

package/esm2015/common/agro-name-utils.class.js

@@ -0,0 +1,59 @@
+import { AgroStringUtils } from "./agro-string-utils.class";
+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+/);
+        // Verifica se há pelo menos duas partes no nome
+        if (parts.length < 2) {
+            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 < 2)
+            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/esm2015/common/agro-number-utils.class.js

@@ -0,0 +1,102 @@
+/**
+ * Classe de utilitários para operações com números.
+ */
+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 % 2 === 0;
+    }
+    /**
+     * 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 % 2 !== 0;
+    }
+    /**
+     * 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 === 0)
+            throw new Error("O total não pode ser zero.");
+        return (partial / total) * 100;
+    }
+    /**
+     * 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) {
+        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 <= 1)
+            return false;
+        for (let i = 2; i <= Math.sqrt(value); i++) {
+            if (value % i === 0)
+                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 = 2) {
+        const factor = Math.pow(10, decimals);
+        return Math.round(value * factor) / factor;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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