@jtandrelevicius/utils-js-library 1.0.0

package/index.js

@@ -0,0 +1,347 @@
+/**
+ * DataQueryService
+ * Responsável pela execução e processamento de consultas assíncronas.
+ */
+class DataQueryService {
+    /**
+     * Define o executor de query padrão para a classe.
+     * Isso remove a dependência de uma função global.
+     * @param {Function} executorFunction Função que aceita (query, params, onSuccess, onError).
+     */
+    static setExecutor(executorFunction) {
+        this.executor = executorFunction;
+    }
+
+    /**
+     * @private
+     * Normaliza a resposta da API, lidando com estruturas aninhadas legadas/específicas.
+     * @param {unknown} rawValue O valor bruto retornado pela query.
+     * @returns {Array<Object>} O array de dados normalizado.
+     */
+    static normalizeResponse(rawValue) {
+        try {
+            const parsedValue = typeof rawValue === 'string' ? JSON.parse(rawValue) : rawValue;
+
+            if (!parsedValue) return [];
+            if (Array.isArray(parsedValue)) return parsedValue;
+
+            let finalData = null;
+
+            if (typeof parsedValue === 'object') {
+                if (typeof parsedValue.b === 'string') {
+                    finalData = JSON.parse(parsedValue.b);
+                } else if (parsedValue.c?.b && typeof parsedValue.c.b === 'string') {
+                    finalData = JSON.parse(parsedValue.c.b);
+                } else if (parsedValue.data?.responseBody || parsedValue.responseBody) {
+                    const body = parsedValue.data?.responseBody || parsedValue.responseBody;
+                    finalData = typeof body === 'string' ? JSON.parse(body) : body;
+                }
+            }
+
+            if (Array.isArray(finalData)) return finalData;
+
+            throw new Error("Formato de resposta desconhecido ou inválido.");
+        } catch (error) {
+            throw new Error(`Falha ao normalizar resposta da query: ${error.message}`);
+        }
+    }
+
+    /**
+     * Executa uma consulta de dados.
+     * @param {string} query A string da consulta (SQL/HQL/etc).
+     * @param {Object} [params=null] Parâmetros opcionais para a query.
+     * @returns {Promise<Array<Object>>} Promise resolvendo com os dados.
+     */
+    static async fetch(query, params = null) {
+        if (typeof this.executor !== 'function') {
+            return Promise.reject(new Error("Executor de query não configurado. Use DataQueryService.setExecutor()."));
+        }
+
+        return new Promise((resolve, reject) => {
+            this.executor(query, params, 
+                (rawValue) => {
+                    try {
+                        const data = DataQueryService.normalizeResponse(rawValue);
+                        resolve(data || []);
+                    } catch (err) {
+                        reject(err);
+                    }
+                }, 
+                (err) => reject(new Error(`Erro na execução da query: ${err}`))
+            );
+        });
+    }
+
+    /**
+     * Executa uma consulta paginada.
+     * @param {string} query A query base.
+     * @param {Object} params Parâmetros da query.
+     * @param {number} limit Registros por página.
+     * @param {number} offset Ponto de início (pular x registros).
+     * @returns {Promise<Object>} Objeto contendo dados e metadados de paginação.
+     */
+    static async fetchPaginated(query, params = null, limit, offset) {
+        const safeLimit = Number(limit);
+        const safeOffset = Number(offset);
+
+        if (isNaN(safeLimit) || isNaN(safeOffset) || safeLimit < 0 || safeOffset < 0) {
+            throw new Error("Parâmetros 'limit' e 'offset' devem ser números positivos válidos.");
+        }
+
+        const paginatedQuery = `${query} LIMIT ${safeLimit} OFFSET ${safeOffset}`;
+
+        const data = await DataQueryService.fetch(paginatedQuery, params);
+        
+        const currentPage = Math.floor(safeOffset / safeLimit) + 1;
+
+        return {
+            data,
+            meta: {
+                currentPage,
+                itemsPerPage: safeLimit,
+                totalItems: null, 
+                totalPages: null 
+            }
+        };
+    }
+}
+
+/**
+ * FormatUtils
+ * Utilitários para formatação de moeda, números e datas (Locale pt-BR).
+ */
+class FormatUtils {
+    /**
+     * Formata valor para moeda BRL (R$).
+     * @param {number|string} value 
+     * @returns {string} Ex: "R$ 1.250,00"
+     */
+    static currency(value) {
+        const numberVal = parseFloat(value);
+        if (isNaN(numberVal)) return "R$ 0,00";
+
+        return new Intl.NumberFormat('pt-BR', {
+            style: 'currency',
+            currency: 'BRL'
+        }).format(numberVal);
+    }
+
+    /**
+     * Formata número inteiro com separadores de milhar.
+     * @param {number|string} value 
+     * @returns {string} Ex: "1.000"
+     */
+    static number(value) {
+        const numberVal = parseFloat(value);
+        if (isNaN(numberVal)) return "0";
+
+        return new Intl.NumberFormat('pt-BR', {
+            maximumFractionDigits: 0
+        }).format(numberVal);
+    }
+    
+    /**
+     * Formata número decimal com 2 casas fixas.
+     * @param {number|string} value 
+     * @returns {string} Ex: "1.200,50"
+     */
+    static decimal(value) {
+        const numberVal = parseFloat(value);
+        if (isNaN(numberVal)) return "0,00";
+
+        return new Intl.NumberFormat('pt-BR', {
+            minimumFractionDigits: 2,
+            maximumFractionDigits: 2
+        }).format(numberVal);
+    }
+
+    /**
+     * Retorna data atual no formato DD/MM/YYYY.
+     * @returns {string}
+     */
+    static currentDate() {
+        return new Intl.DateTimeFormat('pt-BR').format(new Date());
+    }
+
+    /**
+     * Converte string ISO (YYYY-MM-DD) para PT-BR (DD/MM/YYYY).
+     * @param {string} isoDateString 
+     * @returns {string}
+     */
+    static formatDateToBR(isoDateString) {
+        if (!isoDateString) return '';
+        const parts = isoDateString.split('-');
+        if (parts.length !== 3) return isoDateString;
+        
+        // [Ano, Mes, Dia] -> "Dia/Mes/Ano"
+        return `${parts[2]}/${parts[1]}/${parts[0]}`;
+    }
+
+    /**
+     * Retorna data atual em ISO (YYYY-MM-DD).
+     * Útil para inputs HTML tipo date.
+     * @returns {string}
+     */
+    static currentIsoDate() {
+        return new Date().toISOString().split('T')[0];
+    }
+
+    /**
+     * Data e Hora atuais (DD/MM/YYYY HH:mm).
+     * @returns {string}
+     */
+    static currentDateTime() {
+        const now = new Date();
+        const datePart = new Intl.DateTimeFormat('pt-BR').format(now);
+        const timePart = now.toLocaleTimeString('pt-BR', { hour: '2-digit', minute: '2-digit' });
+        return `${datePart} ${timePart}`;
+    }
+}
+
+/**
+ * SortUtils
+ * Utilitários para ordenação de listas.
+ */
+class SortUtils {
+    /**
+     * Ordena array de objetos.
+     * @param {Array<Object>} data Lista original.
+     * @param {string} key Chave do objeto para ordenar.
+     * @param {'asc'|'desc'} direction Direção da ordenação.
+     * @returns {Array<Object>} Nova lista ordenada.
+     */
+    static sortBy(data, key, direction = 'asc') {
+        if (!Array.isArray(data) || !key) return data;
+
+        const multiplier = direction === 'asc' ? 1 : -1;
+
+        return [...data].sort((a, b) => {
+            const valA = a[key];
+            const valB = b[key];
+
+            if (valA == null) return 1; 
+            if (valB == null) return -1;
+
+            if (typeof valA === 'string' && typeof valB === 'string') {
+                return valA.localeCompare(valB) * multiplier;
+            }
+
+            if (valA < valB) return -1 * multiplier;
+            if (valA > valB) return 1 * multiplier;
+            return 0;
+        });
+    }
+}
+
+/**
+ * ExportService
+ * Exportação para Excel (.xlsx) e CSV.
+ */
+class ExportService {
+    static CDN_URL = "https://cdnjs.cloudflare.com/ajax/libs/xlsx/0.18.5/xlsx.full.min.js";
+
+    /**
+     * Carrega biblioteca externa (SheetJS) sob demanda.
+     * @private
+     */
+    static async loadDependency() {
+        if (typeof window !== 'undefined' && window.XLSX) return;
+
+        return new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = this.CDN_URL;
+            script.async = true;
+            script.onload = () => resolve();
+            script.onerror = () => reject(new Error('Falha ao baixar dependência XLSX.'));
+            document.head.appendChild(script);
+        });
+    }
+
+    /**
+     * Gera arquivo Excel.
+     * @param {Array<Object>} data Dados brutos.
+     * @param {Array<{key: string, display: string}>} columns Definição de colunas.
+     * @param {string} filename Nome do arquivo (sem extensão).
+     * @param {string} sheetName Nome da aba.
+     */
+    static async toExcel(data, columns, filename, sheetName = 'Dados') {
+        await this.loadDependency();
+
+        // Mapeia os dados para as chaves de exibição
+        const formattedData = data.map(item => {
+            const row = {};
+            columns.forEach(col => {
+                row[col.display] = item[col.key];
+            });
+            return row;
+        });
+
+        const worksheet = XLSX.utils.json_to_sheet(formattedData);
+        const workbook = XLSX.utils.book_new();
+        XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
+        XLSX.writeFile(workbook, `${filename}.xlsx`);
+    }
+
+    /**
+     * Gera arquivo CSV.
+     * @param {Array<Object>} data Dados brutos.
+     * @param {Array<{key: string, display: string}>} columns Definição de colunas.
+     * @param {string} filename Nome do arquivo (sem extensão).
+     */
+    static toCSV(data, columns, filename) {
+        const headerRow = columns.map(c => `"${c.display}"`).join(';');
+        
+        const bodyRows = data.map(item => {
+            return columns.map(col => {
+                const val = item[col.key] ?? ''; 
+                const stringVal = String(val).replace(/"/g, '""').replace(/\r?\n|\r/g, ' ');
+                return `"${stringVal}"`;
+            }).join(';');
+        });
+
+        const csvContent = [headerRow, ...bodyRows].join('\r\n');
+        
+        const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
+        const link = document.createElement('a');
+        
+        if (link.download !== undefined) { 
+            const url = URL.createObjectURL(blob);
+            link.setAttribute('href', url);
+            link.setAttribute('download', `${filename}.csv`);
+            link.style.visibility = 'hidden';
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+        }
+    }
+
+    /**
+     * Método principal de exportação.
+     */
+    static async export(data, columns, filename = 'export', format = 'xlsx') {
+        if (!data?.length) throw new Error("Sem dados para exportar.");
+        if (!columns?.length) throw new Error("Colunas não definidas.");
+
+        const fmt = format.toLowerCase();
+        
+        if (fmt === 'xlsx') {
+            await this.toExcel(data, columns, filename);
+        } else if (fmt === 'csv') {
+            this.toCSV(data, columns, filename);
+        } else {
+            throw new Error(`Formato '${format}' não suportado. Use 'xlsx' ou 'csv'.`);
+        }
+    }
+}
+
+
+export { 
+    DataQueryService, 
+    FormatUtils, 
+    SortUtils, 
+    ExportService,
+    DataQueryService as JSK,
+    FormatUtils as JFSK,
+    SortUtils as JOSK,
+    ExportService as JEXSK
+};

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@jtandrelevicius/utils-js-library",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Jeferson Tiago Alves Andrelevicius",
+  "license": "ISC"
+}