nyte 1.0.0

package/dist/api/console.js

@@ -0,0 +1,318 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Levels = exports.Colors = exports.DynamicLine = void 0;
+/*
+ * This file is part of the Nyte.js Project.
+ * Copyright (c) 2026 itsmuzin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const boxen_1 = __importDefault(require("boxen"));
+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.
+ */
+class DynamicLine {
+    constructor(initialContent) {
+        // A ID é usada internamente pela classe Console para rastrear esta linha.
+        this._id = Symbol();
+        // 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);
+    }
+}
+exports.DynamicLine = DynamicLine;
+var Colors;
+(function (Colors) {
+    Colors["Reset"] = "\u001B[0m";
+    Colors["Bright"] = "\u001B[1m";
+    Colors["Dim"] = "\u001B[2m";
+    Colors["Underscore"] = "\u001B[4m";
+    Colors["Blink"] = "\u001B[5m";
+    Colors["Reverse"] = "\u001B[7m";
+    Colors["Hidden"] = "\u001B[8m";
+    Colors["FgBlack"] = "\u001B[30m";
+    Colors["FgRed"] = "\u001B[31m";
+    Colors["FgGreen"] = "\u001B[32m";
+    Colors["FgYellow"] = "\u001B[33m";
+    Colors["FgBlue"] = "\u001B[34m";
+    Colors["FgMagenta"] = "\u001B[35m";
+    Colors["FgCyan"] = "\u001B[36m";
+    Colors["FgWhite"] = "\u001B[37m";
+    Colors["FgGray"] = "\u001B[90m";
+    Colors["FgAlmostWhite"] = "\u001B[38;2;220;220;220m";
+    Colors["BgBlack"] = "\u001B[40m";
+    Colors["BgRed"] = "\u001B[41m";
+    Colors["BgGreen"] = "\u001B[42m";
+    Colors["BgYellow"] = "\u001B[43m";
+    Colors["BgBlue"] = "\u001B[44m";
+    Colors["BgMagenta"] = "\u001B[45m";
+    Colors["BgCyan"] = "\u001B[46m";
+    Colors["BgWhite"] = "\u001B[47m";
+    Colors["BgGray"] = "\u001B[100m";
+})(Colors || (exports.Colors = Colors = {}));
+var Levels;
+(function (Levels) {
+    Levels["ERROR"] = "ERROR";
+    Levels["WARN"] = "WARN";
+    Levels["INFO"] = "INFO";
+    Levels["DEBUG"] = "DEBUG";
+    Levels["SUCCESS"] = "SUCCESS";
+})(Levels || (exports.Levels = Levels = {}));
+class Console {
+    // --- MÉTODOS PRIVADOS PARA GERENCIAR A 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.
+            }
+        }
+        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.FgCyan)).join('\n') + '\n');
+        }
+        this.lastRenderedLines = this.activeLines.length;
+    }
+    static writeStatic(content) {
+        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);
+        }
+        if (!content.endsWith('\n'))
+            content += '\n';
+        stream.write(content);
+        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.FgCyan)).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.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;
+                break;
+            // ⟳ : Esse costuma funcionar, mas se virar emoji, use '∞' ou '…'
+            case 'WAIT':
+                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)
+        return ` ${gray}${time}${reset}  ${Colors.Bright + baseColor}${icon} ${bold}${level}${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');
+        }
+    }
+    // --- MÉTODOS DE LOG 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 debug(...args) { this.log(Levels.DEBUG, null, ...args); }
+    static logCustomLevel(levelName, without = true, color, ...args) {
+        if (without) {
+            this.logWithout(levelName, color, ...args);
+        }
+        else {
+            this.log(levelName, color, ...args);
+        }
+    }
+    static logWithout(level, colors, ...args) {
+        this.log(level, colors, ...args);
+    }
+    static log(level, colors, ...args) {
+        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
+                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.FgCyan}?${Colors.Reset} ${question}${Colors.FgGray}${defaultPart}${Colors.Reset} \n ${Colors.FgCyan}➜${Colors.Reset} `;
+        return new Promise(resolve => {
+            readlineInterface.question(prompt, ans => {
+                readlineInterface.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}`);
+        }
+    }
+    static table(data) {
+        let rows;
+        if (Array.isArray(data)) {
+            rows = data.map(row => ({ Field: String(row.Field), Value: String(row.Value) }));
+        }
+        else {
+            rows = Object.entries(data).map(([Field, Value]) => ({ Field, Value: String(Value) }));
+        }
+        const fieldLen = Math.max(...rows.map(r => r.Field.length), 'Field'.length);
+        const valueLen = Math.max(...rows.map(r => r.Value.length), 'Value'.length);
+        const h_line = '─'.repeat(fieldLen + 2);
+        const v_line = '─'.repeat(valueLen + 2);
+        const top = `┌${h_line}┬${v_line}┐`;
+        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 += mid + '\n';
+        for (const row of rows) {
+            output += `│ ${row.Field.padEnd(fieldLen)} │ ${row.Value.padEnd(valueLen)} │\n`;
+        }
+        output += bottom + '\n';
+        this.writeStatic(output);
+    }
+    static box(content, options) {
+        const defaultOptions = {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: 'cyan',
+            titleAlignment: 'left',
+        };
+        const finalOptions = { ...defaultOptions, ...options };
+        const boxedContent = (0, boxen_1.default)(content, finalOptions);
+        this.writeStatic(boxedContent + '\n');
+    }
+    static dynamicLine(initialContent) {
+        return new DynamicLine(initialContent);
+    }
+}
+// Armazena o estado de todas as linhas dinâmicas ativas
+Console.activeLines = [];
+// Quantas linhas foram efetivamente renderizadas na última operação.
+Console.lastRenderedLines = 0;
+exports.default = Console;

package/dist/api/http.d.ts

@@ -0,0 +1,180 @@
+import { GenericRequest, GenericResponse, CookieOptions } from '../types/framework';
+/**
+ * Abstração sobre a requisição HTTP de entrada.
+ * Funciona com qualquer framework web (Express, Fastify, etc.)
+ */
+export declare class NyteRequest {
+    /** A requisição genérica parseada pelo adapter */
+    private readonly _req;
+    constructor(req: GenericRequest);
+    private validateAndSanitizeRequest;
+    /**
+     * Retorna o método HTTP da requisição (GET, POST, etc.)
+     */
+    get method(): string;
+    /**
+     * Retorna a URL completa da requisição
+     */
+    get url(): string;
+    /**
+     * Retorna todos os headers da requisição
+     */
+    get headers(): Record<string, string | string[]>;
+    /**
+     * Retorna um header específico com validação
+     */
+    header(name: string): string | string[] | undefined;
+    /**
+     * Retorna todos os query parameters
+     */
+    get query(): Record<string, any>;
+    /**
+     * Retorna todos os parâmetros de rota
+     */
+    get params(): Record<string, string>;
+    /**
+     * Retorna todos os cookies
+     */
+    get cookies(): Record<string, string>;
+    /**
+     * Retorna um cookie específico com validação
+     */
+    cookie(name: string): string | undefined;
+    /**
+     * Retorna o corpo (body) da requisição, já parseado como JSON com validação
+     */
+    json<T = any>(): Promise<T>;
+    /**
+     * Retorna o corpo da requisição como texto
+     */
+    text(): Promise<string>;
+    /**
+     * Retorna o corpo da requisição como FormData (para uploads)
+     */
+    formData(): Promise<any>;
+    /**
+     * Retorna a requisição original do framework
+     */
+    get raw(): any;
+    /**
+     * Verifica se a requisição tem um content-type específico
+     */
+    is(type: string): boolean;
+    /**
+     * Verifica se a requisição é AJAX/XHR
+     */
+    get isAjax(): boolean;
+    /**
+     * Retorna o IP do cliente com validação melhorada
+     */
+    get ip(): string;
+    private isValidIP;
+    /**
+     * Retorna o User-Agent
+     */
+    get userAgent(): string | undefined;
+}
+/**
+ * Abstração para construir a resposta HTTP.
+ * Funciona com qualquer framework web (Express, Fastify, etc.)
+ */
+export declare class NyteResponse {
+    private _status;
+    private _headers;
+    private _cookies;
+    private _body;
+    private _sent;
+    /**
+     * Define o status HTTP da resposta
+     */
+    status(code: number): NyteResponse;
+    /**
+     * Define um header da resposta
+     */
+    header(name: string, value: string): NyteResponse;
+    /**
+     * Define múltiplos headers
+     */
+    headers(headers: Record<string, string>): NyteResponse;
+    /**
+     * Define um cookie
+     */
+    cookie(name: string, value: string, options?: CookieOptions): NyteResponse;
+    /**
+     * Remove um cookie
+     */
+    clearCookie(name: string, options?: CookieOptions): NyteResponse;
+    /**
+     * Envia resposta JSON
+     */
+    json(data: any): NyteResponse;
+    /**
+     * Envia resposta de texto
+     */
+    text(data: string): NyteResponse;
+    /**
+     * Envia resposta HTML
+     */
+    html(data: string): NyteResponse;
+    /**
+     * Envia qualquer tipo de dados
+     */
+    send(data: any): NyteResponse;
+    /**
+     * Redireciona para uma URL
+     */
+    redirect(url: string, status?: number): NyteResponse;
+    /**
+     * Método interno para aplicar a resposta ao objeto de resposta do framework
+     */
+    _applyTo(res: GenericResponse): void;
+    /**
+     * Método de compatibilidade com versão anterior (Express)
+     */
+    _send(res: any): void;
+    /**
+     * Cria uma resposta JSON
+     */
+    static json(data: any, options?: {
+        status?: number;
+        headers?: Record<string, string>;
+    }): NyteResponse;
+    /**
+     * Cria uma resposta de texto
+     */
+    static text(data: string, options?: {
+        status?: number;
+        headers?: Record<string, string>;
+    }): NyteResponse;
+    /**
+     * Cria uma resposta HTML
+     */
+    static html(data: string, options?: {
+        status?: number;
+        headers?: Record<string, string>;
+    }): NyteResponse;
+    /**
+     * Cria um redirecionamento
+     */
+    static redirect(url: string, status?: number): NyteResponse;
+    /**
+     * Cria uma resposta 404
+     */
+    static notFound(message?: string): NyteResponse;
+    /**
+     * Cria uma resposta 500
+     */
+    static error(message?: string): NyteResponse;
+    /**
+     * Cria uma resposta 400
+     */
+    static badRequest(message?: string): NyteResponse;
+    /**
+     * Cria uma resposta 401
+     */
+    static unauthorized(message?: string): NyteResponse;
+    /**
+     * Cria uma resposta 403
+     */
+    static forbidden(message?: string): NyteResponse;
+}