hightjs 0.5.1 → 0.5.3

package/dist/adapters/native.js

@@ -1,198 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NativeAdapter = void 0;
-const url_1 = require("url");
-// --- Funções Auxiliares de Segurança ---
-/**
- * Remove caracteres de quebra de linha (\r, \n) de uma string para prevenir
- * ataques de HTTP Header Injection (CRLF Injection).
- * @param value O valor a ser sanitizado.
- * @returns A string sanitizada.
- */
-function sanitizeHeaderValue(value) {
-    return String(value).replace(/[\r\n]/g, '');
-}
-/**
- * Valida se o nome de um cookie contém apenas caracteres permitidos pela RFC 6265.
- * Isso previne a criação de cookies com nomes inválidos ou maliciosos.
- * @param name O nome do cookie a ser validado.
- * @returns `true` se o nome for válido, `false` caso contrário.
- */
-function isValidCookieName(name) {
-    // A RFC 6265 define 'token' como 1 ou mais caracteres que não são controle nem separadores.
-    // Separadores: ( ) < > @ , ; : \ " / [ ] ? = { }
-    const validCookieNameRegex = /^[a-zA-Z0-9!#$%&'*+-.^_`|~]+$/;
-    return validCookieNameRegex.test(name);
-}
-class NativeAdapter {
-    constructor() {
-        this.type = 'native';
-    }
-    parseRequest(req) {
-        const url = (0, url_1.parse)(req.url || '', true);
-        return {
-            method: req.method || 'GET',
-            url: req.url || '/',
-            headers: req.headers,
-            // Adicionado fallback para null para maior segurança caso o body parser não tenha rodado.
-            body: req.body ?? null,
-            // Tipo mais específico para a query.
-            query: url.query,
-            params: {}, // Será preenchido pelo roteador
-            cookies: this.parseCookies(req.headers.cookie || ''),
-            raw: req
-        };
-    }
-    createResponse(res) {
-        return new NativeResponseWrapper(res);
-    }
-    parseCookies(cookieHeader) {
-        const cookies = {};
-        if (!cookieHeader)
-            return cookies;
-        cookieHeader.split(';').forEach(cookie => {
-            const [name, ...rest] = cookie.trim().split('=');
-            if (name && rest.length > 0) {
-                try {
-                    // Tenta decodificar o valor do cookie.
-                    cookies[name] = decodeURIComponent(rest.join('='));
-                }
-                catch (e) {
-                    // Prevenção de crash: Ignora cookies com valores malformados (e.g., URI inválida).
-                    console.error(`Warning: Malformed cookie with name "${name}" was ignored.`);
-                }
-            }
-        });
-        return cookies;
-    }
-}
-exports.NativeAdapter = NativeAdapter;
-class NativeResponseWrapper {
-    constructor(res) {
-        this.res = res;
-        this.statusCode = 200;
-        this.headers = {};
-        this.cookiesToSet = []; // Array para lidar corretamente com múltiplos cookies.
-        this.finished = false;
-    }
-    get raw() {
-        return this.res;
-    }
-    status(code) {
-        this.statusCode = code;
-        return this;
-    }
-    header(name, value) {
-        // Medida de segurança CRÍTICA: Previne HTTP Header Injection (CRLF Injection).
-        // Sanitiza tanto o nome quanto o valor do header para remover quebras de linha.
-        const sanitizedName = sanitizeHeaderValue(name);
-        const sanitizedValue = sanitizeHeaderValue(value);
-        if (name !== sanitizedName || String(value) !== sanitizedValue) {
-            console.warn(`Warning: Potential HTTP Header Injection attempt detected and sanitized. Original header: "${name}"`);
-        }
-        this.headers[sanitizedName] = sanitizedValue;
-        return this;
-    }
-    cookie(name, value, options) {
-        // Medida de segurança: Valida o nome do cookie.
-        if (!isValidCookieName(name)) {
-            console.error(`Error: Invalid cookie name "${name}". The cookie will not be set.`);
-            return this;
-        }
-        let cookieString = `${name}=${encodeURIComponent(value)}`;
-        if (options) {
-            // Sanitiza as opções que são strings para prevenir Header Injection.
-            if (options.domain)
-                cookieString += `; Domain=${sanitizeHeaderValue(options.domain)}`;
-            if (options.path)
-                cookieString += `; Path=${sanitizeHeaderValue(options.path)}`;
-            if (options.expires)
-                cookieString += `; Expires=${options.expires.toUTCString()}`;
-            if (options.maxAge)
-                cookieString += `; Max-Age=${options.maxAge}`;
-            if (options.httpOnly)
-                cookieString += '; HttpOnly';
-            if (options.secure)
-                cookieString += '; Secure';
-            if (options.sameSite) {
-                const sameSiteValue = typeof options.sameSite === 'boolean' ? 'Strict' : options.sameSite;
-                cookieString += `; SameSite=${sanitizeHeaderValue(sameSiteValue)}`;
-            }
-        }
-        this.cookiesToSet.push(cookieString);
-        return this;
-    }
-    clearCookie(name, options) {
-        const clearOptions = { ...options, expires: new Date(0), maxAge: 0 };
-        return this.cookie(name, '', clearOptions);
-    }
-    writeHeaders() {
-        if (this.finished)
-            return;
-        this.res.statusCode = this.statusCode;
-        Object.entries(this.headers).forEach(([name, value]) => {
-            this.res.setHeader(name, value);
-        });
-        // CORREÇÃO: Envia múltiplos cookies corretamente como headers 'Set-Cookie' separados.
-        // O método antigo de juntar com vírgula estava incorreto.
-        if (this.cookiesToSet.length > 0) {
-            this.res.setHeader('Set-Cookie', this.cookiesToSet);
-        }
-    }
-    json(data) {
-        if (this.finished)
-            return;
-        this.header('Content-Type', 'application/json; charset=utf-8');
-        this.writeHeaders();
-        const jsonString = JSON.stringify(data);
-        this.res.end(jsonString);
-        this.finished = true;
-    }
-    text(data) {
-        if (this.finished)
-            return;
-        this.header('Content-Type', 'text/plain; charset=utf-8');
-        this.writeHeaders();
-        this.res.end(data);
-        this.finished = true;
-    }
-    send(data) {
-        if (this.finished)
-            return;
-        const existingContentType = this.headers['Content-Type'];
-        if (typeof data === 'string') {
-            if (!existingContentType) {
-                this.header('Content-Type', 'text/plain; charset=utf-8');
-            }
-            this.writeHeaders();
-            this.res.end(data);
-        }
-        else if (Buffer.isBuffer(data)) {
-            this.writeHeaders();
-            this.res.end(data);
-        }
-        else if (data !== null && typeof data === 'object') {
-            this.json(data); // Reutiliza o método json para consistência
-            return; // O método json já finaliza a resposta
-        }
-        else {
-            if (!existingContentType) {
-                this.header('Content-Type', 'text/plain; charset=utf-8');
-            }
-            this.writeHeaders();
-            this.res.end(String(data));
-        }
-        this.finished = true;
-    }
-    redirect(url) {
-        if (this.finished)
-            return;
-        this.status(302);
-        // A sanitização no método .header() previne que um URL manipulado
-        // cause um ataque de Open Redirect via Header Injection.
-        this.header('Location', url);
-        this.writeHeaders();
-        this.res.end();
-        this.finished = true;
-    }
-}

package/dist/api/console.d.ts

@@ -1,94 +0,0 @@
-import { Options as BoxenOptions } from 'boxen';
-/**
- * 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.
- */
-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 {
-    Reset = "\u001B[0m",
-    Bright = "\u001B[1m",
-    Dim = "\u001B[2m",
-    Underscore = "\u001B[4m",
-    Blink = "\u001B[5m",
-    Reverse = "\u001B[7m",
-    Hidden = "\u001B[8m",
-    FgBlack = "\u001B[30m",
-    FgRed = "\u001B[31m",
-    FgGreen = "\u001B[32m",
-    FgYellow = "\u001B[33m",
-    FgBlue = "\u001B[34m",
-    FgMagenta = "\u001B[35m",
-    FgCyan = "\u001B[36m",
-    FgWhite = "\u001B[37m",
-    FgGray = "\u001B[90m",// ← adicionado
-    BgBlack = "\u001B[40m",
-    BgRed = "\u001B[41m",
-    BgGreen = "\u001B[42m",
-    BgYellow = "\u001B[43m",
-    BgBlue = "\u001B[44m",
-    BgMagenta = "\u001B[45m",
-    BgCyan = "\u001B[46m",
-    BgWhite = "\u001B[47m",
-    BgGray = "\u001B[100m"
-}
-export declare enum Levels {
-    ERROR = "ERROR",
-    WARN = "WARN",
-    INFO = "INFO",
-    DEBUG = "DEBUG",
-    SUCCESS = "SUCCESS"
-}
-export default class Console {
-    private static activeLines;
-    private static lastRenderedLines;
-    /**
-     * Limpa todas as linhas dinâmicas da tela e as redesenha com o conteúdo atualizado.
-     * Observação: usamos lastRenderedLines para saber quantas linhas mover
-     * o cursor para cima (isso evita mover para cima demais quando uma nova
-     * linha foi registrada).
-     */
-    private static redrawDynamicLines;
-    /**
-     * Envolve a escrita de texto estático (logs normais) para não interferir
-     * com as linhas dinâmicas.
-     */
-    private static writeStatic;
-    private static registerDynamicLine;
-    private static updateDynamicLine;
-    private static endDynamicLine;
-    static error(...args: any[]): void;
-    static warn(...args: any[]): void;
-    static info(...args: any[]): void;
-    static success(...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;
-    static log(level: Levels, colors?: Colors, ...args: any[]): void;
-    static ask(question: string, defaultValue?: string): Promise<string>;
-    static confirm(message: string, defaultYes?: boolean): Promise<boolean>;
-    static table(data: Record<string, any> | Array<{
-        Field: string;
-        Value: any;
-    }>): void;
-    static box(content: string, options?: BoxenOptions): void;
-    /**
-     * Cria e retorna um controlador para uma linha dinâmica no console.
-     * @param initialContent O conteúdo inicial a ser exibido.
-     * @returns Uma instância de DynamicLine para controlar a linha.
-     */
-    static dynamicLine(initialContent: string): DynamicLine;
-}

package/dist/api/console.js

@@ -1,294 +0,0 @@
-"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 HightJS Project.
- * Copyright (c) 2025 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["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 ---
-    /**
-     * Limpa todas as linhas dinâmicas da tela e as redesenha com o conteúdo atualizado.
-     * Observação: usamos lastRenderedLines para saber quantas linhas mover
-     * o cursor para cima (isso evita mover para cima demais quando uma nova
-     * linha foi registrada).
-     */
-    static redrawDynamicLines() {
-        const stream = process.stdout;
-        // Se anteriormente renderizamos N linhas, movemos o cursor para cima N
-        // para chegar ao topo do bloco dinâmico. Se N for 0, não movemos.
-        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.
-            }
-        }
-        // Posiciona no início da linha e limpa tudo abaixo (removendo o bloco antigo).
-        node_readline_1.default.cursorTo(stream, 0);
-        node_readline_1.default.clearScreenDown(stream);
-        // Reescreve as linhas com o conteúdo atualizado
-        if (this.activeLines.length > 0) {
-            stream.write(this.activeLines.map(l => l.content).join('\n') + '\n');
-        }
-        // Atualiza o contador de linhas que agora estão renderizadas.
-        this.lastRenderedLines = this.activeLines.length;
-    }
-    /**
-     * Envolve a escrita de texto estático (logs normais) para não interferir
-     * com as linhas dinâmicas.
-     */
-    static writeStatic(content) {
-        const stream = process.stdout;
-        // Se há um bloco dinâmico na tela, removemos (limpamos) ele antes de
-        // escrever o conteúdo estático — assim evitamos misturar a saída.
-        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);
-        }
-        // Garante que o conteúdo termine com quebra de linha.
-        if (!content.endsWith('\n'))
-            content += '\n';
-        stream.write(content);
-        // Depois de escrever o log estático, redesenhamos o bloco dinâmico abaixo dele.
-        if (this.activeLines.length > 0) {
-            stream.write(this.activeLines.map(l => l.content).join('\n') + '\n');
-            this.lastRenderedLines = this.activeLines.length;
-        }
-        else {
-            this.lastRenderedLines = 0;
-        }
-    }
-    // --- MÉTODOS CHAMADOS PELA CLASSE DynamicLine ---
-    static registerDynamicLine(id, content) {
-        // Adiciona a nova linha à lista de linhas ativas
-        this.activeLines.push({ id, content });
-        // Redesenha todo o bloco (usa lastRenderedLines internamente)
-        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) {
-            // Remove a linha da lista de ativas.
-            this.activeLines.splice(lineIndex, 1);
-            // Escreve o conteúdo final como uma linha estática.
-            // writeStatic cuidará de limpar e redesenhar as linhas dinâmicas
-            // restantes no lugar certo.
-            this.writeStatic(finalContent + '\n');
-        }
-    }
-    // --- MÉTODOS DE LOG PÚBLICOS (MODIFICADOS) ---
-    static error(...args) { this.log(Levels.ERROR, ...args); }
-    static warn(...args) { this.log(Levels.WARN, ...args); }
-    static info(...args) { this.log(Levels.INFO, ...args); }
-    static success(...args) { this.log(Levels.SUCCESS, ...args); }
-    static debug(...args) { this.log(Levels.DEBUG, ...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) {
-        const color = colors ? colors : level === Levels.ERROR ? Colors.BgRed : level === Levels.WARN ? Colors.BgYellow : level === Levels.INFO ? Colors.BgMagenta : level === Levels.SUCCESS ? Colors.BgGreen : Colors.BgCyan;
-        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)
-                output += `  ${color} ${level} ${Colors.Reset} ${msg}\n`;
-        }
-        this.writeStatic(output);
-    }
-    static log(level, colors, ...args) {
-        const color = colors || level === Levels.ERROR ? Colors.BgRed : level === Levels.WARN ? Colors.BgYellow : level === Levels.INFO ? Colors.BgMagenta : level === Levels.SUCCESS ? Colors.BgGreen : Colors.BgCyan;
-        let output = "\n";
-        for (const arg of args) {
-            let msg = (arg instanceof Error) ? arg.stack : (typeof arg === 'string') ? arg : JSON.stringify(arg, null, 2);
-            if (msg)
-                output += `  ${color} ${level} ${Colors.Reset} ${msg}\n`;
-        }
-        this.writeStatic(output);
-    }
-    // --- OUTROS MÉTODOS ---
-    static async ask(question, defaultValue) {
-        // Garantimos que o bloco dinâmico atual seja temporariamente removido
-        // (redesenhado depois) para não poluir o prompt.
-        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 coloredQuestion = ` ${Colors.FgMagenta}${question}${Colors.Reset}`;
-        const defaultValuePart = defaultValue ? ` [${Colors.Reset}${Colors.FgCyan}${defaultValue}${Colors.Reset}]` : '';
-        const fullPrompt = `${coloredQuestion}${defaultValuePart}:\n > `;
-        return new Promise(resolve => {
-            readlineInterface.question(fullPrompt, ans => {
-                readlineInterface.close();
-                const value = ans.trim();
-                // Redesenha as linhas dinâmicas após o prompt
-                this.redrawDynamicLines();
-                resolve(value === '' && defaultValue !== undefined ? defaultValue : value);
-            });
-        });
-    }
-    static async confirm(message, defaultYes = false) {
-        const suffix = defaultYes ? 'yes' : 'no';
-        while (true) {
-            const ans = (await this.ask(message + " (yes/no)", suffix)).toLowerCase();
-            if (!ans)
-                return defaultYes;
-            if (['y', 'yes'].includes(ans))
-                return true;
-            if (['n', 'no'].includes(ans))
-                return false;
-            this.warn('Resposta inválida, digite y ou n.');
-        }
-    }
-    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 sep = `+${'-'.repeat(fieldLen + 2)}+${'-'.repeat(valueLen + 2)}+`;
-        let output = sep + '\n';
-        output += `| ${Colors.FgGreen}${'Field'.padEnd(fieldLen)}${Colors.Reset} | ${Colors.FgGreen}${'Value'.padEnd(valueLen)}${Colors.Reset} |\n`;
-        output += sep + '\n';
-        for (const row of rows) {
-            output += `| ${row.Field.padEnd(fieldLen)} | ${row.Value.padEnd(valueLen)} |\n`;
-        }
-        output += sep + '\n';
-        this.writeStatic(output);
-    }
-    static box(content, options) {
-        const defaultOptions = {
-            padding: 1,
-            margin: 1,
-            borderStyle: 'round',
-            borderColor: 'whiteBright',
-            titleAlignment: 'left',
-        };
-        const finalOptions = { ...defaultOptions, ...options };
-        const boxedContent = (0, boxen_1.default)(content, finalOptions);
-        this.writeStatic(boxedContent + '\n');
-    }
-    /**
-     * Cria e retorna um controlador para uma linha dinâmica no console.
-     * @param initialContent O conteúdo inicial a ser exibido.
-     * @returns Uma instância de DynamicLine para controlar a linha.
-     */
-    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.
-// Usamos esse contador para evitar off-by-one ao mover o cursor para
-// redesenhar o bloco dinâmico.
-Console.lastRenderedLines = 0;
-exports.default = Console;