exodus-framework 2.1.1031 → 2.1.1033

package/lib/utils/api.d.ts

@@ -1,15 +1,172 @@
 import { AxiosHeaders, AxiosInstance, Method } from 'axios';
 import { IApiResponse } from '../contracts/http';
+/**
+ * Classe abstrata base para criação de clientes HTTP usando Axios.
+ *
+ * Esta classe fornece uma estrutura comum para realizar requisições HTTP
+ * com tratamento de erros padronizado, validação de status customizável
+ * e diferentes tipos de requisições (interna, externa, direta).
+ *
+ * @example
+ * ```typescript
+ * class MyApiClient extends Api {
+ *   host = 'https://api.example.com';
+ *   headers = { 'Authorization': 'Bearer token' };
+ *
+ *   validateStatus(status: number): boolean {
+ *     return status >= 200 && status < 300;
+ *   }
+ * }
+ *
+ * const client = new MyApiClient();
+ * const response = await client.request('/users', 'GET');
+ * ```
+ *
+ * @abstract
+ * @class Api
+ * @version 1.0.0
+ * @author Exodus Framework
+ */
 declare abstract class Api {
+    /** Instância do Axios configurada */
     axios: AxiosInstance;
+    /** URL base para as requisições (deve ser implementado nas classes filhas) */
     abstract host: string;
+    /** Headers padrão para as requisições (deve ser implementado nas classes filhas) */
     abstract headers: Record<string, any>;
+    /**
+     * Construtor da classe Api.
+     * Inicializa automaticamente a instância do Axios.
+     */
     constructor();
+    /**
+     * Inicializa a instância do Axios com configurações padrão.
+     *
+     * @protected
+     * @async
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * // Chamado automaticamente no constructor
+     * await this.init();
+     * ```
+     */
     init(): Promise<void>;
+    /**
+     * Método abstrato para validação de status HTTP.
+     * Deve ser implementado nas classes filhas para definir quais status são considerados válidos.
+     *
+     * @abstract
+     * @param status - Código de status HTTP da resposta
+     * @returns true se o status é válido, false caso contrário
+     *
+     * @example
+     * ```typescript
+     * validateStatus(status: number): boolean {
+     *   return status >= 200 && status < 400; // Aceita 2xx e 3xx
+     * }
+     * ```
+     */
     abstract validateStatus(status: number): boolean;
+    /**
+     * Realiza uma requisição HTTP e retorna apenas os dados da resposta.
+     *
+     * @template T - Tipo dos dados esperados na resposta
+     * @param endpoint - Endpoint da API (será concatenado com host)
+     * @param method - Método HTTP (GET, POST, PUT, DELETE, etc.)
+     * @param data - Dados para envio no corpo da requisição (opcional)
+     * @param params - Parâmetros de query string (opcional)
+     * @param headers - Headers adicionais para a requisição (opcional)
+     * @returns Promise com os dados da resposta ou undefined em caso de erro
+     *
+     * @example
+     * ```typescript
+     * // GET request
+     * const users = await this.request<User[]>('/users', 'GET');
+     *
+     * // POST request com dados
+     * const newUser = await this.request<User>('/users', 'POST', {
+     *   name: 'João',
+     *   email: 'joao@example.com'
+     * });
+     *
+     * // GET com parâmetros
+     * const user = await this.request<User>('/users', 'GET', null, { id: 123 });
+     * ```
+     */
     request<T>(endpoint: string, method: Method, data?: any, params?: any, headers?: AxiosHeaders): Promise<IApiResponse<T> | import("axios").AxiosResponse<T, any, {}>>;
+    /**
+     * Realiza uma requisição HTTP e retorna a resposta completa do Axios.
+     *
+     * Este método é útil quando você precisa acessar headers, status code,
+     * ou outras propriedades da resposta além dos dados.
+     *
+     * @template T - Tipo dos dados esperados na resposta
+     * @param endpoint - Endpoint da API (será concatenado com host)
+     * @param method - Método HTTP (GET, POST, PUT, DELETE, etc.)
+     * @param data - Dados para envio no corpo da requisição (opcional)
+     * @param params - Parâmetros de query string (opcional)
+     * @param headers - Headers adicionais para a requisição (opcional)
+     * @returns Promise com a resposta completa do Axios ou undefined em caso de erro
+     *
+     * @example
+     * ```typescript
+     * const response = await this.requestDirect<User>('/users/1', 'GET');
+     * console.log(response.status); // 200
+     * console.log(response.headers); // Headers da resposta
+     * console.log(response.data); // Dados do usuário
+     * ```
+     */
     requestDirect<T>(endpoint: string, method: Method, data?: any, params?: any, headers?: AxiosHeaders): Promise<import("axios").AxiosResponse<IApiResponse<T>, any, {}> | import("axios").AxiosResponse<T, any, {}>>;
+    /**
+     * Realiza uma requisição HTTP para APIs externas.
+     *
+     * Este método é otimizado para chamadas a APIs de terceiros,
+     * não utilizando a interface IApiResponse padrão do framework.
+     *
+     * @template T - Tipo dos dados esperados na resposta
+     * @param endpoint - Endpoint da API (será concatenado com host)
+     * @param method - Método HTTP (GET, POST, PUT, DELETE, etc.)
+     * @param data - Dados para envio no corpo da requisição (opcional)
+     * @param params - Parâmetros de query string (opcional)
+     * @param headers - Headers adicionais para a requisição (opcional)
+     * @returns Promise com a resposta da API externa ou undefined em caso de erro
+     *
+     * @example
+     * ```typescript
+     * // Chamada para API externa (ex: GitHub)
+     * const githubUser = await this.requestExternal<GitHubUser>(
+     *   '/users/octocat',
+     *   'GET'
+     * );
+     *
+     * // API externa com autenticação
+     * const data = await this.requestExternal<ExternalData>(
+     *   '/api/data',
+     *   'GET',
+     *   null,
+     *   null,
+     *   { 'X-API-Key': 'external-api-key' }
+     * );
+     * ```
+     */
     requestExternal<T>(endpoint: string, method: Method, data?: any, params?: any, headers?: AxiosHeaders): Promise<import("axios").AxiosResponse<T, any, {}>>;
+    /**
+     * Gera um ID de segurança lógica baseado na data atual.
+     *
+     * Este método cria um identificador único baseado na data atual,
+     * útil para implementações de segurança ou cache temporal.
+     *
+     * @protected
+     * @returns String contendo o ID de segurança lógica
+     *
+     * @example
+     * ```typescript
+     * const securityId = this.getLogicalSecurityId();
+     * console.log(securityId); // "1695513600000" (exemplo)
+     * ```
+     */
     protected getLogicalSecurityId(): string;
 }
 export default Api;

package/lib/utils/api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/utils/api.ts"],"names":[],"mappings":"AAAA,OAAc,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,EAAc,MAAM,OAAO,CAAC;AAG/E,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AA6BjD,uBAAe,GAAG;IAEhB,KAAK,EAAE,aAAa,CAAC;IAGrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAGtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;;IAuBhC,IAAI;IA0BV,QAAQ,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IA4B1C,OAAO,CAAC,CAAC,EACb,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,GAAG,EACV,MAAM,CAAC,EAAE,GAAG,EACZ,OAAO,CAAC,EAAE,YAAY;IAwClB,aAAa,CAAC,CAAC,EACnB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,GAAG,EACV,MAAM,CAAC,EAAE,GAAG,EACZ,OAAO,CAAC,EAAE,YAAY;IAkDlB,eAAe,CAAC,CAAC,EACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,GAAG,EACV,MAAM,CAAC,EAAE,GAAG,EACZ,OAAO,CAAC,EAAE,YAAY;IAiCxB,SAAS,CAAC,oBAAoB;CAI/B;AAED,eAAe,GAAG,CAAC"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/utils/api.ts"],"names":[],"mappings":"AAAA,OAAc,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,EAAc,MAAM,OAAO,CAAC;AAG/E,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,uBAAe,GAAG;IAChB,qCAAqC;IACrC,KAAK,EAAE,aAAa,CAAC;IAErB,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,oFAAoF;IACpF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAEtC;;;OAGG;;IAKH;;;;;;;;;;;;OAYG;IACG,IAAI;IAWV;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAEhD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,OAAO,CAAC,CAAC,EACb,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,GAAG,EACV,MAAM,CAAC,EAAE,GAAG,EACZ,OAAO,CAAC,EAAE,YAAY;IAkBxB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,aAAa,CAAC,CAAC,EACnB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,GAAG,EACV,MAAM,CAAC,EAAE,GAAG,EACZ,OAAO,CAAC,EAAE,YAAY;IAkBxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACG,eAAe,CAAC,CAAC,EACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,GAAG,EACV,MAAM,CAAC,EAAE,GAAG,EACZ,OAAO,CAAC,EAAE,YAAY;IAkBxB;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,oBAAoB;CAI/B;AAED,eAAe,GAAG,CAAC"}

package/lib/utils/api.js

@@ -36,17 +36,7 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
  * @author Exodus Framework
  */
 class Api {
-  /** Instância do Axios configurada */
   axios;
-
-  /** URL base para as requisições (deve ser implementado nas classes filhas) */
-
-  /** Headers padrão para as requisições (deve ser implementado nas classes filhas) */
-
-  /**
-   * Construtor da classe Api.
-   * Inicializa automaticamente a instância do Axios.
-   */
   constructor() {
     this.init();
   }

package/lib/utils/database.js

@@ -57,7 +57,6 @@ function processCondition(cond, fieldName) {
       if (dialect === 'postgres') {
         simpleWhere[_sequelize.Op.iLike] = value;
       } else {
-        // Para MariaDB/MySQL, usamos Sequelize.where com função LOWER
         return _sequelize.Sequelize.where(_sequelize.Sequelize.fn('LOWER', _sequelize.Sequelize.col(fieldName)), _sequelize.Op.like, `${value}`.toLowerCase());
       }
     } else {
@@ -71,7 +70,6 @@ function processCondition(cond, fieldName) {
       if (dialect === 'postgres') {
         simpleWhere[_sequelize.Op.notILike] = value;
       } else {
-        // Para MariaDB/MySQL, usamos Sequelize.where com função LOWER
         return _sequelize.Sequelize.where(_sequelize.Sequelize.fn('LOWER', _sequelize.Sequelize.col(fieldName)), _sequelize.Op.notLike, `${value}`.toLowerCase());
       }
     } else {
@@ -103,24 +101,17 @@ function processDateCondition(key, cond) {
   if (cond.between !== undefined) {
     const start = cond.between[0];
     const end = cond.between[1];
-
-    // console.log(start, end);
-
     let startDate = (0, _dateFns.parseISO)(start);
     if ((0, _dateFns.isValid)(startDate) && !hasTime(start)) {
-      // console.log('Ajustando início do dia');
       startDate = (0, _dateFns.startOfDay)(startDate);
     }
     let endDate = (0, _dateFns.parseISO)(end);
     if ((0, _dateFns.isValid)(endDate) && !hasTime(end)) {
-      // console.log('Ajustando fim do dia');
       endDate = (0, _dateFns.endOfDay)(endDate);
     }
     simpleWhere[1] = {
       [_sequelize.Op.between]: [startDate, endDate]
     };
-
-    // console.log('Condição entre processada:', simpleWhere[1]);
   }
   if (cond.notBetween !== undefined) {
     simpleWhere[1] = {
@@ -139,8 +130,6 @@ function processDateCondition(key, cond) {
   }
   return simpleWhere;
 }
-
-// Função Principal para Processar Filtros
 function processFilters(filters) {
   if (!filters) return {};
   const where = {};
@@ -161,22 +150,15 @@ function processFilters(filters) {
     } else {
       const field = key;
       const isDate = condition.type && condition.type === 'DATE';
-      // const isTime = condition.type && condition.type === 'TIME';
-      // const isDateTime = condition.type && condition.type === 'DATETIME';
-
       if (isDate) {
         const [k, c] = processDateCondition(key, condition);
         where[k] = c;
       } else {
         const processedCondition = processCondition(condition, key);
-
-        // Se retornar um Sequelize.where (case insensitive para MariaDB), precisamos tratar diferente
         if (processedCondition && typeof processedCondition === 'object' && processedCondition.comparator) {
-          // É um Sequelize.where
           where[_sequelize.Op.and] = where[_sequelize.Op.and] || [];
           where[_sequelize.Op.and].push(processedCondition);
         } else {
-          // Condição normal
           if (where[field]) {
             where[field] = {
               ...where[field],

package/lib/utils/logger-transport.js

@@ -9,18 +9,13 @@ var _path = _interopRequireDefault(require("path"));
 var _stream = require("stream");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _default(opts) {
-  // garante a pasta existir
   const dir = _path.default.dirname(opts.destination);
   (0, _fs.mkdirSync)(dir, {
     recursive: true
   });
-
-  // abre o arquivo em modo append
   const stream = (0, _fs.createWriteStream)(opts.destination, {
     flags: 'a'
   });
-
-  // map dos níveis numéricos do pino
   const levelMap = {
     trace: 10,
     debug: 20,
@@ -35,12 +30,10 @@ function _default(opts) {
     write(chunk, _enc, cb) {
       chunk = JSON.parse(chunk);
       try {
-        // só grava se exatamente o nível desejado
         if (chunk.level === onlyLevel) {
           stream.write(JSON.stringify(chunk) + '\n');
         }
       } catch (e) {
-        // não atrapalha o fluxo de log
         console.error('custom-target write error', e);
       } finally {
         cb();

package/lib/utils/phone.d.ts

@@ -1,22 +1,193 @@
+/**
+ * Classe utilitária para manipulação e validação de números de telefone brasileiros.
+ *
+ * Esta classe utiliza a biblioteca `libphonenumber-js` para parsing e validação,
+ * oferecendo métodos para extrair componentes do telefone (DDI, DDD, nono dígito)
+ * e formatação em diferentes padrões.
+ *
+ * @example
+ * ```typescript
+ * // Criando uma instância com número brasileiro
+ * const phone = new Phone('(11) 99999-8888');
+ *
+ * // Verificando se é válido
+ * console.log(phone.isValidPhone()); // true
+ *
+ * // Obtendo componentes
+ * console.log(phone.getDDD()); // '11'
+ * console.log(phone.hasNine()); // true
+ *
+ * // Formatação
+ * console.log(phone.getMaskedPhone()); // '+55 (11) 9 9999-8888'
+ * console.log(phone.getPhone(false, true, true)); // '1199999888'
+ * ```
+ *
+ * @class Phone
+ * @version 1.0.0
+ * @author Exodus Framework
+ */
 declare class Phone {
     private phone;
+    /** Código do país (DDI) */
     private ddi;
+    /** Código de área (DDD) */
     private ddd;
+    /** Nono dígito para celulares */
     private nine;
+    /** Primeira parte do número (4 primeiros dígitos) */
     private phonePart1;
+    /** Segunda parte do número (4 últimos dígitos) */
     private phonePart2;
+    /** Indica se o número é válido */
     private isValid;
+    /** Número limpo (apenas dígitos) */
     private number;
+    /**
+     * Cria uma nova instância da classe Phone.
+     *
+     * @param phone - Número de telefone em qualquer formato (com ou sem máscara)
+     *
+     * @example
+     * ```typescript
+     * const phone1 = new Phone('11999998888');
+     * const phone2 = new Phone('(11) 99999-8888');
+     * const phone3 = new Phone('+55 11 99999-8888');
+     * ```
+     */
     constructor(phone: string);
+    /**
+     * Retorna o código do país (DDI).
+     *
+     * @returns O DDI do número (ex: '55' para Brasil)
+     *
+     * @example
+     * ```typescript
+     * const phone = new Phone('+55 11 99999-8888');
+     * console.log(phone.getDDI()); // '55'
+     * ```
+     */
     getDDI(): string;
+    /**
+     * Retorna o código de área (DDD).
+     *
+     * @returns O DDD do número (ex: '11' para São Paulo)
+     *
+     * @example
+     * ```typescript
+     * const phone = new Phone('(11) 99999-8888');
+     * console.log(phone.getDDD()); // '11'
+     * ```
+     */
     getDDD(): string;
+    /**
+     * Verifica se o número possui o nono dígito (celular).
+     *
+     * @returns true se possui o nono dígito, false caso contrário
+     *
+     * @example
+     * ```typescript
+     * const celular = new Phone('11999998888');
+     * const fixo = new Phone('1133334444');
+     * console.log(celular.hasNine()); // true
+     * console.log(fixo.hasNine()); // false
+     * ```
+     */
     hasNine(): boolean;
+    /**
+     * Retorna o número limpo (apenas dígitos).
+     *
+     * @returns Número sem formatação, apenas dígitos
+     *
+     * @example
+     * ```typescript
+     * const phone = new Phone('(11) 99999-8888');
+     * console.log(phone.getNumber()); // '11999998888'
+     * ```
+     */
     getNumber(): string;
+    /**
+     * Retorna o número formatado com máscara.
+     *
+     * @param ddi - Incluir DDI na formatação (padrão: true)
+     * @param ddd - Incluir DDD na formatação (padrão: true)
+     * @param nine - Incluir nono dígito na formatação (padrão: true)
+     * @returns Número formatado com máscara
+     *
+     * @example
+     * ```typescript
+     * const phone = new Phone('5511999998888');
+     * console.log(phone.getMaskedPhone()); // '+55 (11) 9 9999-8888'
+     * console.log(phone.getMaskedPhone(false)); // '(11) 9 9999-8888'
+     * console.log(phone.getMaskedPhone(true, false)); // '+55 9 9999-8888'
+     * ```
+     */
     getMaskedPhone(ddi?: boolean, ddd?: boolean, nine?: boolean): string;
+    /**
+     * Retorna o número sem formatação, incluindo apenas os componentes selecionados.
+     *
+     * @param ddi - Incluir DDI no resultado (padrão: true)
+     * @param ddd - Incluir DDD no resultado (padrão: true)
+     * @param nine - Incluir nono dígito no resultado (padrão: true)
+     * @returns Número sem formatação
+     *
+     * @example
+     * ```typescript
+     * const phone = new Phone('5511999998888');
+     * console.log(phone.getPhone()); // '5511999998888'
+     * console.log(phone.getPhone(false)); // '11999998888'
+     * console.log(phone.getPhone(false, true, false)); // '1199998888'
+     * ```
+     */
     getPhone(ddi?: boolean, ddd?: boolean, nine?: boolean): string;
+    /**
+     * Retorna a primeira parte do número (primeiros 4 dígitos após DDD/nono dígito).
+     *
+     * @returns Primeira parte do número
+     *
+     * @example
+     * ```typescript
+     * const phone = new Phone('11999998888');
+     * console.log(phone.getPhonePart1()); // '9999'
+     * ```
+     */
     getPhonePart1(): string;
+    /**
+     * Retorna a segunda parte do número (últimos 4 dígitos).
+     *
+     * @returns Segunda parte do número
+     *
+     * @example
+     * ```typescript
+     * const phone = new Phone('11999998888');
+     * console.log(phone.getPhonePart2()); // '8888'
+     * ```
+     */
     getPhonePart2(): string;
+    /**
+     * Retorna o número original fornecido no construtor.
+     *
+     * @returns Número original sem alterações
+     *
+     * @example
+     * ```typescript
+     * const phone = new Phone('(11) 99999-8888');
+     * console.log(phone.getOriginalPhone()); // '(11) 99999-8888'
+     * ```
+     */
     getOriginalPhone(): string;
+    /**
+     * Verifica se o número de telefone é válido.
+     *
+     * @returns true se o número é válido, false caso contrário
+     *
+     * @example
+     * ```typescript
+     * const validPhone = new Phone('11999998888');
+     * const invalidPhone = new Phone('123');
+     * console.log(validPhone.isValidPhone()); // true
+     * console.log(invalidPhone.isValidPhone()); // false
+     * ```
+     */
     isValidPhone(): boolean;
 }
 export default Phone;

package/lib/utils/phone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"phone.d.ts","sourceRoot":"","sources":["../../src/utils/phone.ts"],"names":[],"mappings":"AA8BA,cAAM,KAAK;IAkCG,OAAO,CAAC,KAAK;IAhCzB,OAAO,CAAC,GAAG,CAAS;IAGpB,OAAO,CAAC,GAAG,CAAS;IAGpB,OAAO,CAAC,IAAI,CAAS;IAGrB,OAAO,CAAC,UAAU,CAAS;IAG3B,OAAO,CAAC,UAAU,CAAS;IAG3B,OAAO,CAAC,OAAO,CAAU;IAGzB,OAAO,CAAC,MAAM,CAAS;gBAcH,KAAK,EAAE,MAAM;IAuD1B,MAAM;IAeN,MAAM;IAiBN,OAAO;IAeP,SAAS;IAoBT,cAAc,CAAC,GAAG,UAAO,EAAE,GAAG,UAAO,EAAE,IAAI,UAAO;IA2BlD,QAAQ,CAAC,GAAG,UAAO,EAAE,GAAG,UAAO,EAAE,IAAI,UAAO;IAqB5C,aAAa;IAeb,aAAa;IAeb,gBAAgB;IAiBhB,YAAY,IAAI,OAAO;CAG/B;AAED,eAAe,KAAK,CAAC"}
+{"version":3,"file":"phone.d.ts","sourceRoot":"","sources":["../../src/utils/phone.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,cAAM,KAAK;IAkCG,OAAO,CAAC,KAAK;IAjCzB,2BAA2B;IAC3B,OAAO,CAAC,GAAG,CAAS;IAEpB,2BAA2B;IAC3B,OAAO,CAAC,GAAG,CAAS;IAEpB,iCAAiC;IACjC,OAAO,CAAC,IAAI,CAAS;IAErB,qDAAqD;IACrD,OAAO,CAAC,UAAU,CAAS;IAE3B,kDAAkD;IAClD,OAAO,CAAC,UAAU,CAAS;IAE3B,kCAAkC;IAClC,OAAO,CAAC,OAAO,CAAU;IAEzB,oCAAoC;IACpC,OAAO,CAAC,MAAM,CAAS;IAEvB;;;;;;;;;;;OAWG;gBACiB,KAAK,EAAE,MAAM;IA4CjC;;;;;;;;;;OAUG;IACI,MAAM;IAIb;;;;;;;;;;OAUG;IACI,MAAM;IAIb;;;;;;;;;;;;OAYG;IACI,OAAO;IAId;;;;;;;;;;OAUG;IACI,SAAS;IAIhB;;;;;;;;;;;;;;;OAeG;IACI,cAAc,CAAC,GAAG,UAAO,EAAE,GAAG,UAAO,EAAE,IAAI,UAAO;IAWzD;;;;;;;;;;;;;;;OAeG;IACI,QAAQ,CAAC,GAAG,UAAO,EAAE,GAAG,UAAO,EAAE,IAAI,UAAO;IAUnD;;;;;;;;;;OAUG;IACI,aAAa;IAIpB;;;;;;;;;;OAUG;IACI,aAAa;IAIpB;;;;;;;;;;OAUG;IACI,gBAAgB;IAIvB;;;;;;;;;;;;OAYG;IACI,YAAY,IAAI,OAAO;CAG/B;AAED,eAAe,KAAK,CAAC"}

package/lib/utils/phone.js

@@ -34,25 +34,12 @@ var _libphonenumberJs = require("libphonenumber-js");
  * @author Exodus Framework
  */
 class Phone {
-  /** Código do país (DDI) */
   ddi;
-
-  /** Código de área (DDD) */
   ddd;
-
-  /** Nono dígito para celulares */
   nine;
-
-  /** Primeira parte do número (4 primeiros dígitos) */
   phonePart1;
-
-  /** Segunda parte do número (4 últimos dígitos) */
   phonePart2;
-
-  /** Indica se o número é válido */
   isValid;
-
-  /** Número limpo (apenas dígitos) */
   number;
 
   /**
@@ -69,45 +56,31 @@ class Phone {
    */
   constructor(phone) {
     this.phone = phone;
-    // Remove todos os caracteres não numéricos
     this.number = phone.replace(/\D/g, '');
-
-    // Utiliza libphonenumber-js para parsing do número brasileiro
     const parsed = (0, _libphonenumberJs.parsePhoneNumberFromString)(this.number, 'BR');
     this.isValid = !!parsed;
-
-    // Se não foi possível fazer o parse, marca como inválido
     if (!parsed) {
       this.isValid = false;
       return;
     }
-
-    // Extrai o DDI (código do país)
     this.ddi = parsed.countryCallingCode;
-
-    // Processa baseado no tamanho do número nacional
     if (parsed.nationalNumber.length > 10) {
-      // Celular com DDD e nono dígito (11 dígitos)
       this.ddd = parsed.nationalNumber.slice(0, 2);
       this.nine = parsed.nationalNumber[2];
       this.phonePart1 = parsed.nationalNumber.slice(3, 7);
       this.phonePart2 = parsed.nationalNumber.slice(7, parsed.nationalNumber.length);
     } else if (parsed.nationalNumber.length == 10) {
-      // Telefone fixo com DDD (10 dígitos)
       this.ddd = parsed.nationalNumber.slice(0, 2);
       this.phonePart1 = parsed.nationalNumber.slice(2, 6);
       this.phonePart2 = parsed.nationalNumber.slice(6, parsed.nationalNumber.length);
     } else if (parsed.nationalNumber.length >= 9) {
-      // Celular sem DDD mas com nono dígito (9 dígitos)
       this.nine = parsed.nationalNumber[0];
       this.phonePart1 = parsed.nationalNumber.slice(1, 5);
       this.phonePart2 = parsed.nationalNumber.slice(5, parsed.nationalNumber.length);
     } else if (parsed.nationalNumber.length == 8) {
-      // Telefone fixo sem DDD (8 dígitos)
       this.phonePart1 = parsed.nationalNumber.slice(0, 4);
       this.phonePart2 = parsed.nationalNumber.slice(4, parsed.nationalNumber.length);
     } else {
-      // Número inválido
       this.isValid = false;
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exodus-framework",
-  "version": "2.1.1031",
+  "version": "2.1.1033",
   "description": "Exodus Framework",
   "author": "jhownpaixao",
   "license": "ISC",