vatts 1.2.0-test.5 → 1.2.0

package/dist/api/console.d.ts

@@ -1,20 +1,10 @@
 /**
- * Um "handle" para uma linha dinâmica. As instâncias desta classe
- * são retornadas por `Console.dynamicLine()` e usadas para controlar
- * o conteúdo da linha.
+ * Handle para linhas dinâmicas.
  */
 export declare class DynamicLine {
     private readonly _id;
     constructor(initialContent: string);
-    /**
-     * Atualiza o conteúdo da linha no console.
-     * @param newContent O novo texto a ser exibido.
-     */
     update(newContent: string): void;
-    /**
-     * Finaliza a linha, opcionalmente com um texto final, e a torna estática.
-     * @param finalContent O texto final a ser exibido.
-     */
     end(finalContent: string): void;
 }
 export declare enum Colors {
@@ -58,13 +48,16 @@ export default class Console {
     private static redrawDynamicLines;
     private static writeStatic;
     private static formatLog;
-    private static registerDynamicLine;
-    private static updateDynamicLine;
-    private static endDynamicLine;
+    /**
+     * Menu de seleção interativo usando setas do teclado.
+     * @param options Objeto no formato { "valor_retornado": "Label Exibida" }
+     */
+    static selection<T = string>(question: string, options: Record<string, T>): Promise<string>;
     static error(...args: any[]): void;
     static warn(...args: any[]): void;
     static info(...args: any[]): void;
     static success(...args: any[]): void;
+    static default_log(...args: any[]): void;
     static debug(...args: any[]): void;
     static logCustomLevel(levelName: string, without?: boolean, color?: Colors, ...args: any[]): void;
     static logWithout(level: Levels, colors?: Colors, ...args: any[]): void;
@@ -76,4 +69,7 @@ export default class Console {
         Value: any;
     }>): void;
     static dynamicLine(initialContent: string): DynamicLine;
+    private static registerDynamicLine;
+    private static updateDynamicLine;
+    private static endDynamicLine;
 }

package/dist/api/console.js

@@ -22,28 +22,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Levels = exports.Colors = exports.DynamicLine = void 0;
 const node_readline_1 = __importDefault(require("node:readline"));
 /**
- * Um "handle" para uma linha dinâmica. As instâncias desta classe
- * são retornadas por `Console.dynamicLine()` e usadas para controlar
- * o conteúdo da linha.
+ * Handle para linhas dinâmicas.
  */
 class DynamicLine {
-    // A ID é usada internamente pela classe Console para rastrear esta linha.
     _id = Symbol();
     constructor(initialContent) {
-        // Registra esta nova linha na classe Console para que ela seja renderizada.
         Console['registerDynamicLine'](this._id, initialContent);
     }
-    /**
-     * Atualiza o conteúdo da linha no console.
-     * @param newContent O novo texto a ser exibido.
-     */
     update(newContent) {
         Console['updateDynamicLine'](this._id, newContent);
     }
-    /**
-     * Finaliza a linha, opcionalmente com um texto final, e a torna estática.
-     * @param finalContent O texto final a ser exibido.
-     */
     end(finalContent) {
         Console['endDynamicLine'](this._id, finalContent);
     }
@@ -87,27 +75,21 @@ var Levels;
     Levels["SUCCESS"] = "SUCCESS";
 })(Levels || (exports.Levels = Levels = {}));
 class Console {
-    // Armazena o estado de todas as linhas dinâmicas ativas
     static activeLines = [];
-    // Quantas linhas foram efetivamente renderizadas na última operação.
     static lastRenderedLines = 0;
-    // --- MÉTODOS PRIVADOS PARA GERENCIAR A RENDERIZAÇÃO ---
+    // --- RENDERIZAÇÃO ---
     static redrawDynamicLines() {
         const stream = process.stdout;
         if (this.lastRenderedLines > 0) {
             try {
                 node_readline_1.default.moveCursor(stream, 0, -this.lastRenderedLines);
             }
-            catch (_e) {
-                // Em terminais estranhos a movimentação pode falhar — ignoramos.
-            }
+            catch { }
         }
         node_readline_1.default.cursorTo(stream, 0);
         node_readline_1.default.clearScreenDown(stream);
         if (this.activeLines.length > 0) {
-            // ATUALIZADO: Aplica o formato de log (Timestamp + Style) nas linhas dinâmicas
-            // Usamos um nível pseudo 'WAIT' para indicar processo em andamento
-            stream.write(this.activeLines.map(l => this.formatLog('WAIT', l.content, Colors.FgRed)).join('\n') + '\n');
+            stream.write(this.activeLines.map(l => this.formatLog('WAIT', l.content)).join('\n') + '\n');
         }
         this.lastRenderedLines = this.activeLines.length;
     }
@@ -117,105 +99,136 @@ class Console {
             try {
                 node_readline_1.default.moveCursor(stream, 0, -this.lastRenderedLines);
             }
-            catch (_e) { }
+            catch { }
             node_readline_1.default.cursorTo(stream, 0);
             node_readline_1.default.clearScreenDown(stream);
         }
-        // MODIFICAÇÃO PRINCIPAL:
-        // Substituímos stream.write por console.log aqui.
-        // O console.log é interceptado pelos debuggers (VSCode, etc), o stream.write não.
-        // Removemos a quebra de linha final (\n$) pois o console.log já adiciona uma automaticamente.
         console.log(content.replace(/\n$/, ''));
         if (this.activeLines.length > 0) {
-            // ATUALIZADO: Garante que ao redesenhar após um log estático, o formato se mantém
-            stream.write(this.activeLines.map(l => this.formatLog('WAIT', l.content, Colors.FgRed)).join('\n') + '\n');
+            stream.write(this.activeLines.map(l => this.formatLog('WAIT', l.content)).join('\n') + '\n');
             this.lastRenderedLines = this.activeLines.length;
         }
         else {
             this.lastRenderedLines = 0;
         }
     }
-    // --- HELPER DE FORMATAÇÃO CENTRALIZADO ---
     static formatLog(level, message, color) {
         let icon = '•';
         let baseColor = Colors.FgWhite;
         switch (level) {
-            // ✕ : Multiplication X (Matemático, sempre texto)
             case Levels.ERROR:
                 icon = '✕';
                 baseColor = Colors.FgRed;
                 break;
-            // ⚠ : Muitas vezes vira emoji. O triângulo ▲ é mais seguro e fica bonito colorido
-            // Alternativa: '‼'
             case Levels.WARN:
                 icon = '▲';
                 baseColor = Colors.FgYellow;
                 break;
-            // ℹ : Vira emoji. O '𝐢' é um "i" matemático em negrito (Math Bold Small I)
-            // Ele mantém a cor que você definir e parece muito um ícone.
             case Levels.INFO:
-                icon = '𝐢';
-                baseColor = Colors.FgRed; // ALTERADO: Agora é vermelho (o Bright é aplicado abaixo)
+                icon = 'ℹ';
+                baseColor = Colors.FgCyan;
                 break;
-            // ✔ : Às vezes vira emoji verde. O '✓' simples costuma obedecer a cor.
-            // Se der erro, use '√' (raiz quadrada)
             case Levels.SUCCESS:
                 icon = '✓';
                 baseColor = Colors.FgGreen;
                 break;
-            // ⚙ : Vira emoji cinza. Use '›' ou '»' ou '⌗' para debug
             case Levels.DEBUG:
                 icon = '›';
-                baseColor = Colors.FgMagenta;
+                baseColor = Colors.FgGray;
                 break;
-            // ⟳ : Esse costuma funcionar, mas se virar emoji, use '∞' ou '…'
             case 'WAIT':
-                icon = '∞';
-                baseColor = Colors.FgRed;
+                icon = '○';
+                baseColor = Colors.FgCyan;
                 break;
             default:
                 icon = '•';
                 baseColor = color || Colors.FgWhite;
                 break;
         }
-        if (color) {
-            baseColor = color;
-        }
         const gray = Colors.FgGray;
         const bold = Colors.Bright;
         const reset = Colors.Reset;
-        const now = new Date();
-        const time = now.toLocaleTimeString('pt-BR', { hour12: false });
-        // Retorna a string formatada SEM quebra de linha (quem chama decide onde por)
-        // O Colors.Bright + baseColor garante que será Bright Red
-        return ` ${gray}${time}${reset}  ${Colors.Bright + baseColor}${icon} ${bold}${level}${reset}  ${message}`;
+        const time = new Date().toLocaleTimeString('pt-BR', { hour12: false });
+        const levelStr = level === 'WAIT' ? '' : ` ${bold}${level}${reset}`;
+        return ` ${gray}${time}${reset}  ${baseColor}${icon}${levelStr}${reset}  ${message}`;
     }
-    // --- MÉTODOS CHAMADOS PELA CLASSE DynamicLine ---
-    static registerDynamicLine(id, content) {
-        this.activeLines.push({ id, content });
-        this.redrawDynamicLines();
-    }
-    static updateDynamicLine(id, newContent) {
-        const line = this.activeLines.find(l => l.id === id);
-        if (line) {
-            line.content = newContent;
-            this.redrawDynamicLines();
-        }
-    }
-    static endDynamicLine(id, finalContent) {
-        const lineIndex = this.activeLines.findIndex(l => l.id === id);
-        if (lineIndex > -1) {
-            this.activeLines.splice(lineIndex, 1);
-            // ATUALIZADO: Formata a mensagem final como INFO (ou SUCCESS implícito)
-            // para manter consistência visual com o resto dos logs.
-            this.writeStatic(this.formatLog(Levels.INFO, finalContent) + '\n');
+    // --- INTERATIVIDADE (SELECTION) ---
+    /**
+     * Menu de seleção interativo usando setas do teclado.
+     * @param options Objeto no formato { "valor_retornado": "Label Exibida" }
+     */
+    static async selection(question, options) {
+        const entries = Object.entries(options);
+        let currentIndex = 0;
+        const stream = process.stdout;
+        let firstRender = true;
+        if (this.lastRenderedLines > 0) {
+            node_readline_1.default.moveCursor(stream, 0, -this.lastRenderedLines);
+            node_readline_1.default.cursorTo(stream, 0);
+            node_readline_1.default.clearScreenDown(stream);
         }
+        stream.write('\x1b[?25l'); // Hide cursor
+        const render = () => {
+            // Se não for a primeira vez, sobe as linhas do menu anterior para sobrescrever
+            if (!firstRender) {
+                node_readline_1.default.moveCursor(stream, 0, -(entries.length + 1));
+            }
+            node_readline_1.default.cursorTo(stream, 0);
+            node_readline_1.default.clearScreenDown(stream);
+            stream.write(` ${Colors.FgCyan}?${Colors.Reset} ${Colors.Bright}${question}${Colors.Reset}\n`);
+            entries.forEach(([key, label], i) => {
+                const isSelected = i === currentIndex;
+                const prefix = isSelected ? `${Colors.FgCyan}❯${Colors.Reset}` : ' ';
+                const text = isSelected ? `${Colors.FgCyan}${Colors.Bright}${label}${Colors.Reset}` : `${Colors.FgGray}${label}${Colors.Reset}`;
+                stream.write(`  ${prefix} ${text}\n`);
+            });
+            firstRender = false;
+        };
+        render();
+        return new Promise((resolve) => {
+            const handleKey = (_chunk, key) => {
+                if (!key)
+                    return;
+                if (key.name === 'up') {
+                    currentIndex = (currentIndex - 1 + entries.length) % entries.length;
+                    render();
+                }
+                else if (key.name === 'down') {
+                    currentIndex = (currentIndex + 1) % entries.length;
+                    render();
+                }
+                else if (key.name === 'return') {
+                    process.stdin.removeListener('keypress', handleKey);
+                    if (process.stdin.isTTY)
+                        process.stdin.setRawMode(false);
+                    process.stdin.pause();
+                    stream.write('\x1b[?25h'); // Show cursor
+                    // Limpa o menu final antes de escrever o log estático
+                    node_readline_1.default.moveCursor(stream, 0, -(entries.length + 1));
+                    node_readline_1.default.cursorTo(stream, 0);
+                    node_readline_1.default.clearScreenDown(stream);
+                    const [selectedKey, selectedLabel] = entries[currentIndex];
+                    this.writeStatic(` ${Colors.FgCyan}✓${Colors.Reset} ${Colors.Bright}${question}${Colors.Reset} ${Colors.FgGray}›${Colors.Reset} ${selectedLabel}`);
+                    resolve(selectedKey);
+                }
+                else if (key.ctrl && key.name === 'c') {
+                    stream.write('\x1b[?25h');
+                    process.exit();
+                }
+            };
+            node_readline_1.default.emitKeypressEvents(process.stdin);
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.on('keypress', handleKey);
+        });
     }
-    // --- MÉTODOS DE LOG PÚBLICOS ---
+    // --- MÉTODOS PÚBLICOS ---
     static error(...args) { this.log(Levels.ERROR, null, ...args); }
     static warn(...args) { this.log(Levels.WARN, null, ...args); }
     static info(...args) { this.log(Levels.INFO, null, ...args); }
     static success(...args) { this.log(Levels.SUCCESS, null, ...args); }
+    static default_log(...args) { this.log(Levels.INFO, null, ...args); }
     static debug(...args) { this.log(Levels.DEBUG, null, ...args); }
     static logCustomLevel(levelName, without = true, color, ...args) {
         if (without) {
@@ -232,50 +245,29 @@ class Console {
         let output = "";
         for (const arg of args) {
             let msg = (arg instanceof Error) ? arg.stack : (typeof arg === 'string') ? arg : JSON.stringify(arg, null, 2);
-            if (msg) {
-                // ATUALIZADO: Usa o helper formatLog
+            if (msg)
                 output += this.formatLog(level, msg, colors) + '\n';
-            }
         }
-        // Remove a última quebra de linha porque writeStatic já garante uma
         this.writeStatic(output.replace(/\n$/, ''));
     }
-    // --- OUTROS MÉTODOS ---
     static async ask(question, defaultValue) {
-        const stream = process.stdout;
-        if (this.lastRenderedLines > 0) {
-            try {
-                node_readline_1.default.moveCursor(stream, 0, -this.lastRenderedLines);
-            }
-            catch (_e) { }
-            node_readline_1.default.cursorTo(stream, 0);
-            node_readline_1.default.clearScreenDown(stream);
-        }
-        const readlineInterface = node_readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
-        const defaultPart = defaultValue ? ` (${defaultValue})` : '';
-        const prompt = ` ${Colors.FgRed}?${Colors.Reset} ${question}${Colors.FgGray}${defaultPart}${Colors.Reset} \n ${Colors.FgRed}➜${Colors.Reset} `;
+        const rl = node_readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
+        const defaultPart = defaultValue ? ` ${Colors.FgGray}(${defaultValue})${Colors.Reset}` : '';
+        const prompt = ` ${Colors.FgCyan}?${Colors.Reset} ${Colors.Bright}${question}${Colors.Reset}${defaultPart}\n ${Colors.FgCyan}❯${Colors.Reset} `;
         return new Promise(resolve => {
-            readlineInterface.question(prompt, ans => {
-                readlineInterface.close();
+            rl.question(prompt, ans => {
+                rl.close();
                 const value = ans.trim();
-                this.redrawDynamicLines();
                 resolve(value === '' && defaultValue !== undefined ? defaultValue : value);
             });
         });
     }
     static async confirm(message, defaultYes = false) {
         const suffix = defaultYes ? 'Y/n' : 'y/N';
-        while (true) {
-            const ans = (await this.ask(`${message} ${Colors.FgGray}[${suffix}]${Colors.Reset}`)).toLowerCase();
-            if (ans === '')
-                return defaultYes;
-            if (['y', 'yes', 's', 'sim'].includes(ans))
-                return true;
-            if (['n', 'no', 'nao', 'não'].includes(ans))
-                return false;
-            // ATUALIZADO: Formato consistente
-            this.writeStatic(`  ${Colors.FgRed}✖ Opção inválida.${Colors.Reset}`);
-        }
+        const ans = (await this.ask(`${message} ${Colors.FgGray}[${suffix}]${Colors.Reset}`)).toLowerCase();
+        if (ans === '')
+            return defaultYes;
+        return ['y', 'yes', 's', 'sim'].includes(ans);
     }
     static table(data) {
         let rows;
@@ -293,7 +285,7 @@ class Console {
         const mid = `├${h_line}┼${v_line}┤`;
         const bottom = `└${h_line}┴${v_line}┘`;
         let output = top + '\n';
-        output += `│ ${Colors.Bright}${Colors.FgGreen}${'Field'.padEnd(fieldLen)}${Colors.Reset} │ ${Colors.Bright}${Colors.FgGreen}${'Value'.padEnd(valueLen)}${Colors.Reset} │\n`;
+        output += `│ ${Colors.Bright}${Colors.FgCyan}${'Field'.padEnd(fieldLen)}${Colors.Reset} │ ${Colors.Bright}${Colors.FgCyan}${'Value'.padEnd(valueLen)}${Colors.Reset} │\n`;
         output += mid + '\n';
         for (const row of rows) {
             output += `│ ${row.Field.padEnd(fieldLen)} │ ${row.Value.padEnd(valueLen)} │\n`;
@@ -304,5 +296,23 @@ class Console {
     static dynamicLine(initialContent) {
         return new DynamicLine(initialContent);
     }
+    static registerDynamicLine(id, content) {
+        this.activeLines.push({ id, content });
+        this.redrawDynamicLines();
+    }
+    static updateDynamicLine(id, newContent) {
+        const line = this.activeLines.find(l => l.id === id);
+        if (line) {
+            line.content = newContent;
+            this.redrawDynamicLines();
+        }
+    }
+    static endDynamicLine(id, finalContent) {
+        const index = this.activeLines.findIndex(l => l.id === id);
+        if (index > -1) {
+            this.activeLines.splice(index, 1);
+            this.writeStatic(this.formatLog(Levels.SUCCESS, finalContent));
+        }
+    }
 }
 exports.default = Console;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vatts",
-  "version": "1.2.0-test.5",
+  "version": "1.2.0",
   "description": "Vatts.js is a high-level framework for building web applications with ease and speed. It provides a robust set of tools and features to streamline development and enhance productivity.",
   "types": "dist/index.d.ts",
   "author": "itsmuzin",