@sankhyalabs/core 2.3.6 → 2.4.0

package/src/utils/DateUtils.ts

@@ -1,10 +1,32 @@
-export default class DateUtils{
+import { number } from "yargs";
 
+/**
+ * `DateUtils`: Utilizado para formatação, padronização e cálculos de datas. 
+ */
+export default class DateUtils{
+    
+     /**
+     * Zerar o horário de uma data.
+     * 
+     * @param date - Data a ser manipulada.
+     * @param adjustDayLightSavingTime - Ajusta horário de verão na data recebida.
+     * @returns - Data sem as informações de horário.
+     * @example
+     * Informo: 2023-03-09 12:42:40      | Obtenho: 2023-03-09 00:00:00 
+     */
     public static clearTime(date:Date, adjustDayLightSavingTime:boolean = true): Date {
         const newDate: Date = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0);
         return adjustDayLightSavingTime ? DateUtils.adjustDLST(newDate) : newDate;
     }
   
+    /**
+     * Converte String para Date.
+     * 
+     * @param strValue - Texto a ser convertido para data.
+     * @param adjustDayLightSavingTime - Se verdadeiro, ativa regra de horário de verão.
+     * @param monthYearMode - Quando ativado, retorna o primeiro dia do mês apenas para construir a data.
+     * @returns - Data sem as informações de horário.
+     */
     public static strToDate(strValue:string, adjustDayLightSavingTime:boolean = true, monthYearMode:boolean = false): Date | undefined {
         /** monthYearMode é um booleano para usar o formato MM/YYYY. 
          * Quando ativado, é retornado o primeiro dia do mês apenas para construir a data. 
@@ -41,7 +63,13 @@ export default class DateUtils{
         return date;
     }
 
-    public static getToday(withTime: boolean = false) {
+    /**
+     * Obtém a data atual.
+     * 
+     * @param withTime - Caso true retorna a data com informações de horário.
+     * @returns - Data atual sem informação de horário. 
+     */
+    public static getToday(withTime: boolean = false): Date {
         const today = new Date();
 
         if (withTime) {
@@ -51,15 +79,27 @@ export default class DateUtils{
         }
     }
 
+    /**
+     * Retorna se a data é válida.
+     * 
+     * @param value - Data a ser validada.
+     * @param hasTime - Determina se a data retornada deve conter informação de horário ou não. Por padrão não retorna a hora.
+     * @returns - Caso válida, retorna a própria data.
+     */
     public static validateDate(value: Date, hasTime: boolean = false): Date | undefined {
       return value instanceof Date && !isNaN(value.valueOf())
         ? hasTime ? value : DateUtils.clearTime(value)
         : undefined;
     }
 
+    /**
+     * Realiza correção do horário de verão.
+     * 
+     * @param date - Data a ser ajustada.
+     * @returns - Data informada ajustada para horário de verão.
+     */
     private static adjustDLST(date:Date): Date {
         
-        //Work around para corrigir o Bug do horário de verão.
         if(date.getHours() == 23){
             return new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1, 1, 0, 0, 0);
         }
@@ -67,11 +107,27 @@ export default class DateUtils{
         return date;
     }
 
-    private static pad(n: Number) {
+    /**
+     * Adiciona uma casa decimal a esquerda de uma unidade.
+     * 
+     * @param n - Número a ser ajustado
+     * @returns - O número informado, com uma casa decimal a esquerda. 
+     * @example
+     * Informo: 15     | Obtenho: 15
+     * @example
+     * Informo:  2     | Obtenho: "02"
+     */    
+    private static pad(n: Number): string | Number {
         return n < 10 ? "0" + n : n;
     }
 
-    private static timezoneOffset(offset: number) {
+    /**
+     * Retorna timezone da data.
+     * 
+     * @param offset - Valor do timezone desejado.
+     * @returns Timezone da data.
+     */ 
+    private static timezoneOffset(offset: number): string {
         let sign;
 
         if (offset === 0) {
@@ -84,7 +140,15 @@ export default class DateUtils{
         return sign + this.pad(Math.floor(offset / 60)) + ":" + this.pad(offset % 60);
     }
   
-    public static formatRfc3339(date: Date) {
+    /**
+     * Converte a data para o formato RFC3339.
+     * 
+     * @param date - Data a ser convertida
+     * @returns - Data informada no formato RFC3339.
+     * * @example
+     * Informo: 2023-03-09 12:42:40     | Obtenho: 2023-03-09T12:42:47-03:00
+     */ 
+    public static formatRfc3339(date: Date): string {
     
         return date.getFullYear() + "-" +
             this.pad(date.getMonth() + 1) + "-" +

package/src/utils/ElementIDUtils.ts

@@ -6,12 +6,21 @@ export interface IElementIDInfo {
 	id?: string,
 	dataUnit?: DataUnit
 }
-
+/**
+ * `ElementIDUtils`: O ElementIDUtils é um utilitário responsável por criar e adicionar identificadores únicos aos componentes através do atributo data-element-id. A finalidade dele é otimizar a automação dos testes e melhorar a eficiência na manipulação dos componentes do Design System, garantindo seleções precisas e seguras.
+ */
 export class ElementIDUtils {
-
   public static DATA_ELEMENT_ID_ATTRIBUTE_NAME: string = "data-element-id";
   public static INTERNAL_INPUT_NAME: string = "internal";
 
+  /**
+  * Cria e adiciona a propriedade `data-element-id` em um elemento.
+  * 
+  * @param element - Elemento HTML a ser modificado (HTMLElement).
+  * @param suffix - Sufixo/Texto para ser adicionado.
+  * @param iDInfo - ID para ser adicionado.
+  * @returns - O data-element-id gerado.
+  */ 
   public static addIDInfo(element: HTMLElement, suffix?: string, iDInfo?: IElementIDInfo): string {
     let dataElementID = this.getDataElementID(element, suffix, iDInfo);
     dataElementID = StringUtils.replaceAccentuatedChars(dataElementID, false);
@@ -22,7 +31,6 @@ export class ElementIDUtils {
   }
 
   public static addIDInfoIfNotExists(element: HTMLElement, suffix?: string, iDInfo?: IElementIDInfo): string {
-    
     let dataElementID = element.getAttribute(ElementIDUtils.DATA_ELEMENT_ID_ATTRIBUTE_NAME);
 
     if(dataElementID == undefined){
@@ -36,6 +44,14 @@ export class ElementIDUtils {
     return `${originalID}_${ElementIDUtils.INTERNAL_INPUT_NAME}_${sufix}`;
   }
 
+  /**
+  * Obtém o `data-element-id` do elemento com adição do sufixo e ID.
+  * 
+  * @param element - Elemento HTML a ser modificado (HTMLElement).
+  * @param suffix - Sufixo/Texto para ser adicionado.
+  * @param iDInfo - ID para ser adicionado.
+  * @returns - Atributo `data-element-id` do elemento modificado com sufixo e/ou ID.
+  */ 
   private static getDataElementID(element: HTMLElement, suffix?: string, iDInfo?: IElementIDInfo) {
     let dataElementID = ElementIDUtils.getDataElementIDAttribute(element);
     if(dataElementID != null){
@@ -53,6 +69,13 @@ export class ElementIDUtils {
     return tagName;
   }
 
+  /**
+  * Obtém ID válido para o elemento.
+  * 
+  * @param element - Elemento HTML a ser modificado (HTMLElement).
+  * @param iDInfo - ID para ser adicionado.
+  * @returns - ID para ser adicionado ao elemento conforme ordem de prioridade.
+  */ 
   private static getAttributeValid(element: HTMLElement, iDInfo?: IElementIDInfo): string | null{
     if(iDInfo?.id){
       return StringUtils.toCamelCase(iDInfo?.id);
@@ -81,6 +104,18 @@ export class ElementIDUtils {
     return null;
   }
 
+  /**
+  * Adiciona sufixo ao atributo `data-element-id` de um elemento, utilizado para montar a hierarquia dos ids dos componentes em tela.
+  * 
+  * @param dataElementID - ID para ser adicionado ao `data-element-id`.
+  * @param suffix - Sufixo/Texto para ser adicionado ao `data-element-id`.
+  * @param element - Elemento HTML a ser modificado (HTMLElement).
+  * @returns - `data-element-id` com sufixo.
+  * 
+  * @example
+  * Um ez-combo-box tem data-element-id = codparc_input_internal_combo.
+  * Dentro desse ez-combo-box existe um ez-text-input. O data-element-id teria como sufixo o id 'codparc_input_internal_combo' referente ao seu pai.
+  */ 
   private static addSuffix(dataElementID: string | null, suffix: string | undefined, element: HTMLElement): string{
     if(suffix){
       return `${dataElementID}_${StringUtils.toCamelCase(suffix)}`;
@@ -91,6 +126,13 @@ export class ElementIDUtils {
     return `${dataElementID}_${StringUtils.toCamelCase(element.tagName)}`; 
   }
 
+  /**
+  * Adiciona a propriedade name do DataUnit como prefixo do data-element-id do elemento.
+  * 
+  * @param iDInfo - ID para ser adicionado ao `data-element-id`.
+  * @param dataElementID - Sufixo/Texto para ser adicionado ao `data-element-id`.
+  * @returns - String contendo informação para ser usada no `data-element-id` do elemento.
+  */ 
   private static addPrefix(iDInfo: IElementIDInfo | undefined, dataElementID: string): string {
     const dataUnitName: string = iDInfo?.dataUnit?.name || "";
     if (iDInfo?.dataUnit && !dataElementID?.startsWith(dataUnitName)) {
@@ -98,7 +140,13 @@ export class ElementIDUtils {
     }
     return dataElementID;
   }
-
+  
+  /**
+  * Remove caracteres especiais.
+  * 
+  * @param value - Texto que terá os caracteres especiais removidos.
+  * @returns - Retorna a string sem caracteres especiais e em camelCase.
+  */ 
   private static formatDescription(value: string | null): string{
     if(!value) return "";
     return StringUtils.toCamelCase((value.replace(/[^\w\sÀ-ÖØ-öø-ÿ]/gi, " ")).replace(/\s+/g, ' ').trim());

package/src/utils/MaskFormatter.ts

@@ -1,6 +1,6 @@
 /**
  * `MaskFormatter` é usado para formatar strings. Seu comportamento
- * é controlado pela formato do atributo `mask` que especifica quais
+ * é controlado pelo 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).
@@ -11,7 +11,7 @@
  * |:---------:|-------------------------------------------------------------------------------------------------------------|
  * | #         | 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.                                                 |
+ * | U         | Qualquer letra. Transforma letras minú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.                                                           |
@@ -20,12 +20,12 @@
  * 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'
+ * Quando 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
+ * Por padrão será usado um espaço em branco como 'placeHolder', mas
  * esse valor pode ser alterado.
  * 
- * For por exemplo:
+ * Por exemplo:
  * '''
  *    const formatter: MaskFormatter = new MaskFormatter("###-####");
  *    formatter.placeholder = '_';
@@ -58,8 +58,8 @@ export class MaskFormatter {
     private _maskChars: Array<MaskFormatter.MaskCharacter> = new Array<MaskFormatter.MaskCharacter>();
 
     /**
-     * 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
+     * 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.
      */
     public placeholder: string = ' ';
 
@@ -72,7 +72,7 @@ export class MaskFormatter {
     }
 
     /**
-     * Getter para mask
+     * Getter para mask.
      *
      * @return A última máscara informada.
      */
@@ -87,8 +87,8 @@ export class MaskFormatter {
     /**
      * 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
+     * @param value Valor a ser formatado.
+     * @return O valor processado de acordo com o padrão.
      */
     public format(value: string): string {
         let result: string = '';
@@ -105,7 +105,7 @@ export class MaskFormatter {
     }
 
     /**
-     * Preparamos a formatação internamente de acordo com o padrão.
+     * Prepara a formatação internamente de acordo com o padrão.
      */
     private updateInternalMask(): void {
 
@@ -165,7 +165,7 @@ export class MaskFormatter {
             this.type = type;
         }
         /**
-         * Cada subclasse deve sobrescrever o retornando true, caso represente
+         * Cada subclasse deve sobrescrever retornando true caso represente.
          * um caractere literal. Por padrão o retorno é false.
          */
         public isLiteral(): boolean {
@@ -173,12 +173,10 @@ export class MaskFormatter {
         }
 
         /**
-         * 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.
+         * Retorna se é um texto válido.
+         * 
+         * @param aChar - Valor a ser validado.
+         * @returns - Retorna se é um texto válido.
          */
         public isValidCharacter(aChar: string): boolean {
             if (this.isLiteral()) {
@@ -191,18 +189,34 @@ export class MaskFormatter {
         }
 
         /**
-         * 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.
+         * Retorna o texto informado.
+         * 
+         * @param aChar - Texto a ser retornado.
+         * @returns - Texto informado.
          */
         public getChar(aChar: string): string {
             return aChar;
         }
 
         /**
-         * Appends the necessary character in <code>formatting</code> at
-         * <code>index</code> to <code>buff</code>.
+         * Adiciona valor encontrado.
+         * 
+         * @param result - String a ser manipulada.
+         * @param formatting - String de formatação a ser adicionada na result.
+         * @param index - Índice que será utilizado para buscar no parâmetro formatting.
+         * 
+         * @returns - Valor passado na result incrementado com o valor encontrado na formatting.
+         * 
+         * @example
+         * ```  const result = "";
+         *       const formatting = "123456";
+         *       const index = [0];
+         *       const returnedResult = append(result, formatting, index);
+         *   ```
+         *   Retorna:
+         *   ```returnedResult = "1";
+         *      index = [1];
+         *   ```
          */
         public append(result: string, formatting: string, index: Array<number>): string {
 
@@ -227,7 +241,14 @@ export class MaskFormatter {
 
             return result;
         }
-
+        
+        /**
+         * Obtém tipo por extenso.
+         * 
+         * @returns O tipo por extenso.
+         * @example
+         * Se o tipo for **ALPHA_NUMERIC_KEY** recebo **uma letra ou um número**
+         */   
         public getFormatMessage(): string{
             let message: string;
             switch(this.type){
@@ -270,20 +291,51 @@ export class MaskFormatter {
 
     private static DigitMaskCharacter = class extends MaskFormatter.MaskCharacter {
 
+        /**
+         * Valida se o caracter é válido.
+         * 
+         * @param aChar - Caracter a ser validado.
+         * @returns - Se o caracter é valido ou não.
+         */  
         public isValidCharacter(aChar: string): boolean {
             return (this.isDigit(aChar) && super.isValidCharacter(aChar));
         }
 
+        /**
+         * Valida se é um numéro.
+         * 
+         * @param char - String a ser verificada.
+         * @returns - Verdadeiro para caracteres numéricos.
+         * 
+         * @example
+         * ```Informado: "8" | Retorno: true ```
+         * @example
+         * ```Informado: "A" | Retorno: false ```
+         */  
         private isDigit(char: string): boolean {
             return char >= '0' && char <= '9'
         }
     }
 
+    
     private static UpperCaseCharacter = class extends MaskFormatter.MaskCharacter {
+
+        /**
+        * Valida se a string é uma letra do alfabeto (a-z).
+        * 
+        * @param aChar - String passada para validação.
+        * @returns - Verdadeiro se a string passada for uma letra do alfabeto.
+        */ 
         public isValidCharacter(aChar: string): boolean {
             return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
         }
 
+        /**
+        * Obtém a string passada em maiúscula.
+        * 
+        * @param aChar - String passada para validação.
+        * @returns - O caracter passado em letra maiúscula.
+        */ 
         public getChar(aChar: string): string {
             return aChar.toUpperCase();
         }
@@ -291,10 +343,22 @@ export class MaskFormatter {
 
     private static LowerCaseCharacter = class extends MaskFormatter.MaskCharacter {
 
+        /**
+        * Valida se a string é uma letra do alfabeto (a-z).
+        * 
+        * @param aChar - String passada para validação.
+        * @returns - Verdadeiro se a string passada for uma letra do alfabeto.
+        */ 
         public isValidCharacter(aChar: string): boolean {
             return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
         }
 
+        /**
+        * Obtém a string passada em minúscula.
+        * 
+        * @param aChar - String passada para validação.
+        * @returns - O caracter passado em letra minúscula.
+        */ 
         public getChar(aChar: string): string {
             return aChar.toLocaleLowerCase();
         }
@@ -302,13 +366,25 @@ export class MaskFormatter {
 
     private static AlphaNumericCharacter = class extends MaskFormatter.MaskCharacter {
 
+        /**
+        * Valida se a string é uma letra do alfabeto (a-z) ou um numero entre zero e nove.
+        * 
+        * @param aChar - String passada para validação.
+        * @returns - Verdadeiro se a string passada for uma letra do alfabeto ou um numeral (de 0 a 9).
+        */ 
         public isValidCharacter(aChar: string): boolean {
-            //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata
+            //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata.
             return (/[a-z0-9]/i.test(aChar)) && super.isValidCharacter(aChar);
         }
     }
 
     private static CharCharacter = class extends MaskFormatter.MaskCharacter {
+        /**
+        * Valida se a string é uma letra do alfabeto (a-z).
+        * 
+        * @param aChar - String passada para validação.
+        * @returns - Verdadeiro se a string passada for uma letra do alfabeto.
+        */ 
         public isValidCharacter(aChar: string): boolean {
             //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata
             return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
@@ -320,4 +396,4 @@ export class MaskFormatter {
 
 export namespace MaskFormatter {
     export type MaskCharacter = InstanceType<typeof MaskFormatter.MaskCharacter>;
-}
+}

package/src/utils/NumberUtils.ts

@@ -3,26 +3,15 @@ import { StringUtils } from "./StringUtils.js";
 const NUMBERINPUTS_REGEX_SCIENTIFIC_PARTS: RegExp = /^([+-])?(\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";
+ * `NumberUtils`: Utilizado para manipulação de numerais.
  */
 export class NumberUtils {
-
-
-
-
     /**
-    * @stringToNumber: converte um numero em formato de string em numero
+    * Converte o dado numérico de string para number.
     * 
-    * @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
+    * @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
@@ -72,13 +61,15 @@ export class NumberUtils {
 
 
     /**
-    * @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"
+    * Formata o numeral com a precisão informada.
     * 
-    * @param value numero em formato de string a ser convertido (Importante: formato PT-BR ou já em formato numérico - sem separador de milhares: ######.##)
-    * @param precision (numero de decimais)
-    * @param prettyPrecision (numero de zeros nos decimais)
+    * @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 numero em formato de string formatado em PT-BR
+    * @returns - Numeral em formato de String formatado em PT-BR.
+    * @example
+    * Informado: ('10,9845444', 3, 3) | Retorna: '10,985'
     */
     static format = (value: string, precision: number, prettyPrecision: number = NaN): string => {
 
@@ -137,12 +128,14 @@ export class NumberUtils {
 
 
     /**
-    * @keepOnlyDecimalSeparator: retira os separadores de milhar de um número em formato de string
+    * Retira os separadores de milhar de um numeral 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")
+    * @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 numero em formato de string formatado apenas com separador decimal
+    * @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 => {
 
@@ -162,11 +155,15 @@ export class NumberUtils {
     }
 
     /**
-    * @changeFormat: troca o formato do numero string de "PT-BR" para "EN-US" e vice-versa
+    * Troca o formato do numeral(string) de "PT-BR" para "EN-US" e vice-versa.
     * 
-    * @param value numero em formato de string a ser convertido
+    * @param value - Numeral em formato de string a ser convertido.
     * 
-    * @returns numero em formato de string formatado de "PT-BR" para "EN-US" e vice-versa
+    * @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
@@ -176,12 +173,19 @@ export class NumberUtils {
     
 
     /**
-    * @getValueOrDefault: retorna o valor passado como number, caso NaN retorna o defaultValue
+    * 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.
     * 
-    * @param value numero a ser validado
-    * @param defaultValue numero a ser retornado caso o value seja inválido
+    * @returns - O próprio numeral passado ou zero.
     * 
-    * @returns o proprio numero 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;
@@ -196,13 +200,13 @@ export class NumberUtils {
     }
 
     /**
-    * @getValueOrZero: valida se o parametro é undefined caso seja retorna zero.
+    * Obtém o valor ou zero, caso o valor seja inválido(NaN/undefined).
     * 
-    * @param value numero a ser validado
+    * @param value - Numeral a ser validado.
     * 
-    * @returns o proprio numero passado ou zero
+    * @returns - O próprio numeral passado. Caso esse seja inválido retorna zero.
     */
      static getValueOrZero = (value: any): number => {
         return NumberUtils.getValueOrDefault(value, 0);
     }
-}
+}

package/src/utils/ObjectUtils.ts

@@ -1,13 +1,41 @@
+/**
+ * `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(data:Object | Array<Object>):Object | Array<Object> | null{
         return this.stringToObject(this.objectToString(data));
     }
 
+    /**
+     * 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)
     }