vatts 1.1.4-alpha.9 → 1.2.0-alpha.2

package/dist/adapters/express.js

@@ -2,9 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExpressAdapter = void 0;
 class ExpressAdapter {
-    constructor() {
-        this.type = 'express';
-    }
+    type = 'express';
     parseRequest(req) {
         return {
             method: req.method,
@@ -23,6 +21,7 @@ class ExpressAdapter {
 }
 exports.ExpressAdapter = ExpressAdapter;
 class ExpressResponseWrapper {
+    res;
     constructor(res) {
         this.res = res;
     }

package/dist/adapters/factory.js

@@ -42,6 +42,7 @@ const console_1 = __importStar(require("../api/console"));
  * Factory para criar o adapter correto baseado no framework detectado
  */
 class FrameworkAdapterFactory {
+    static adapter = null;
     /**
      * Detecta automaticamente o framework baseado na requisição/resposta
      */
@@ -118,4 +119,3 @@ class FrameworkAdapterFactory {
     }
 }
 exports.FrameworkAdapterFactory = FrameworkAdapterFactory;
-FrameworkAdapterFactory.adapter = null;

package/dist/adapters/fastify.js

@@ -2,9 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FastifyAdapter = void 0;
 class FastifyAdapter {
-    constructor() {
-        this.type = 'fastify';
-    }
+    type = 'fastify';
     parseRequest(req) {
         return {
             method: req.method,
@@ -23,6 +21,7 @@ class FastifyAdapter {
 }
 exports.FastifyAdapter = FastifyAdapter;
 class FastifyResponseWrapper {
+    reply;
     constructor(reply) {
         this.reply = reply;
     }

package/dist/adapters/native.js

@@ -24,9 +24,7 @@ function isValidCookieName(name) {
     return validCookieNameRegex.test(name);
 }
 class NativeAdapter {
-    constructor() {
-        this.type = 'native';
-    }
+    type = 'native';
     parseRequest(req) {
         // URL absoluta é obrigatória para a API WHATWG
         const fullUrl = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
@@ -70,12 +68,13 @@ class NativeAdapter {
 }
 exports.NativeAdapter = NativeAdapter;
 class NativeResponseWrapper {
+    res;
+    statusCode = 200;
+    headers = {};
+    cookiesToSet = []; // Array para lidar corretamente com múltiplos cookies.
+    finished = false;
     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;

package/dist/api/console.js

@@ -27,9 +27,9 @@ const node_readline_1 = __importDefault(require("node:readline"));
  * o conteúdo da linha.
  */
 class DynamicLine {
+    // A ID é usada internamente pela classe Console para rastrear esta linha.
+    _id = Symbol();
     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);
     }
@@ -87,6 +87,10 @@ 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 ---
     static redrawDynamicLines() {
         const stream = process.stdout;
@@ -117,9 +121,11 @@ class Console {
             node_readline_1.default.cursorTo(stream, 0);
             node_readline_1.default.clearScreenDown(stream);
         }
-        if (!content.endsWith('\n'))
-            content += '\n';
-        stream.write(content);
+        // 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');
@@ -299,8 +305,4 @@ class Console {
         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/framework.d.ts

@@ -0,0 +1,2 @@
+export declare let cachedFramework: 'react' | 'vue' | null;
+export default function detectFramework(projectDir?: string): "react" | "vue";

package/dist/api/framework.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachedFramework = void 0;
+exports.default = detectFramework;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+// Variável para armazenar o resultado em memória
+exports.cachedFramework = null;
+function detectFramework(projectDir = process.cwd()) {
+    // Se já tivermos um resultado, retorna ele direto sem ler o disco
+    if (exports.cachedFramework)
+        return exports.cachedFramework;
+    try {
+        const pkgPath = path_1.default.join(projectDir, 'package.json');
+        if (fs_1.default.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (deps.react || deps['react-dom']) {
+                exports.cachedFramework = 'react';
+                return exports.cachedFramework;
+            }
+            if (deps.vue || deps['nuxt']) {
+                exports.cachedFramework = 'vue';
+                return exports.cachedFramework;
+            }
+        }
+    }
+    catch (e) {
+        // Ignora erro de leitura
+    }
+    // Salva o fallback no cache para evitar re-execução em caso de falha
+    exports.cachedFramework = 'react';
+    return exports.cachedFramework;
+}

package/dist/api/http.js

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VattsResponse = exports.VattsRequest = void 0;
 // Input validation and sanitization utilities
 class SecurityUtils {
+    static MAX_HEADER_LENGTH = 8192;
+    static MAX_COOKIE_LENGTH = 4096;
+    static MAX_URL_LENGTH = 2048;
+    static MAX_BODY_SIZE = 10 * 1024 * 1024; // 10MB
     static sanitizeHeader(value) {
         if (Array.isArray(value)) {
             return value.map(v => this.sanitizeString(v, this.MAX_HEADER_LENGTH));
@@ -34,15 +38,13 @@ class SecurityUtils {
         return length >= 0 && length <= this.MAX_BODY_SIZE;
     }
 }
-SecurityUtils.MAX_HEADER_LENGTH = 8192;
-SecurityUtils.MAX_COOKIE_LENGTH = 4096;
-SecurityUtils.MAX_URL_LENGTH = 2048;
-SecurityUtils.MAX_BODY_SIZE = 10 * 1024 * 1024; // 10MB
 /**
  * Abstração sobre a requisição HTTP de entrada.
  * Funciona com qualquer framework web (Express, Fastify, etc.)
  */
 class VattsRequest {
+    /** A requisição genérica parseada pelo adapter */
+    _req;
     constructor(req) {
         // Validate and sanitize request data
         this._req = this.validateAndSanitizeRequest(req);
@@ -253,13 +255,11 @@ exports.VattsRequest = VattsRequest;
  * Funciona com qualquer framework web (Express, Fastify, etc.)
  */
 class VattsResponse {
-    constructor() {
-        this._status = 200;
-        this._headers = {};
-        this._cookies = [];
-        this._body = null;
-        this._sent = false;
-    }
+    _status = 200;
+    _headers = {};
+    _cookies = [];
+    _body = null;
+    _sent = false;
     /**
      * Define o status HTTP da resposta
      */

package/dist/bin/vatts.js

@@ -16,48 +16,40 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-// Registra o ts-node para que o Node.js entenda TypeScript/TSX
 require('ts-node').register();
-// Registra loaders customizados para arquivos markdown, imagens, etc.
 const { registerLoaders } = require('../loaders');
 registerLoaders();
 const { program } = require('commander');
 const fs = require('fs');
 const path = require('path');
 const { Writable } = require('stream');
-// Importa o Console do framework
 const ConsoleModule = require('../api/console');
+const { loadVattsConfig, config, setConfig } = require("../helpers");
+const { default: detectFramework } = require("../api/framework");
+const { renderAsStream } = require("../renderer");
 const Console = ConsoleModule.default;
 const { Levels, Colors } = ConsoleModule;
 program
     .version('1.0.0')
     .description('CLI to manage the application.');
 // --- Helpers ---
-/**
- * Função centralizada para iniciar a aplicação
- * @param {object} options - Opções vindas do commander
- * @param {boolean} isDev - Define se é modo de desenvolvimento
- */
 function initializeApp(options, isDev) {
     const appOptions = {
         dev: isDev,
         port: options.port,
         hostname: options.hostname,
         framework: 'native',
-        ssl: null, // Default
+        ssl: null,
     };
-    // 1. Verifica se a flag --ssl foi ativada
     if (options.ssl) {
         const sslDir = path.resolve(process.cwd(), 'certs');
         const keyPath = path.join(sslDir, 'key.pem');
         const certPath = path.join(sslDir, 'cert.pem');
-        // 2. Verifica se os arquivos existem
         if (fs.existsSync(keyPath) && fs.existsSync(certPath)) {
             appOptions.ssl = {
                 key: keyPath,
                 cert: certPath
             };
-            // 3. Adiciona a porta de redirecionamento
             appOptions.ssl.redirectPort = options.httpRedirectPort || 80;
         }
         else {
@@ -65,14 +57,10 @@ function initializeApp(options, isDev) {
             process.exit(1);
         }
     }
-    // 4. Inicia o helper com as opções
     const helperModule = require("../helpers");
     const helper = helperModule.default(appOptions);
     helper.init();
 }
-/**
- * Função corrigida para copiar diretórios recursivamente.
- */
 function copyDirRecursive(src, dest) {
     try {
         fs.mkdirSync(dest, { recursive: true });
@@ -94,136 +82,115 @@ function copyDirRecursive(src, dest) {
     }
 }
 // --- Comandos ---
-// Comando DEV
 program
     .command('dev')
     .description('Starts the application in development mode.')
     .option('-p, --port <number>', 'Specifies the port to run on', '3000')
     .option('-H, --hostname <string>', 'Specifies the hostname to run on', '0.0.0.0')
-    .option('--ssl', 'Activates HTTPS/SSL mode (requires ./ssl/key.pem and ./ssl/cert.pem)')
+    .option('--ssl', 'Activates HTTPS/SSL mode')
     .option('--http-redirect-port <number>', 'Port for HTTP->HTTPS redirection', '80')
     .action((options) => {
     initializeApp(options, true);
 });
-// Comando START (Produção)
 program
     .command('start')
     .description('Starts the application in production mode.')
     .option('-p, --port <number>', 'Specifies the port to run on', '3000')
     .option('-H, --hostname <string>', 'Specifies the hostname to run on', '0.0.0.0')
-    .option('--ssl', 'Activates HTTPS/SSL mode (requires ./ssl/key.pem and ./ssl/cert.pem)')
+    .option('--ssl', 'Activates HTTPS/SSL mode')
     .option('--http-redirect-port <number>', 'Port for HTTP->HTTPS redirection', '80')
     .action((options) => {
     initializeApp(options, false);
 });
-// Comando EXPORT
 program
     .command('export')
     .description('Exports the application as static HTML to the "exported" folder.')
     .option('-o, --output <path>', 'Specifies the output directory', 'exported')
-    .option('--assets-dir <path>', 'Directory (inside output) where the .vatts assets will be written', '.vatts')
+    .option('--assets-dir <path>', 'Directory where the .vatts assets will be written', '.vatts')
     .option('--no-html', 'Do not generate index.html (assets only)')
-    .option('--output-h-data <file>', 'Write the data-h value from <script id="__vatts_data__" data-h="..."> into this file')
+    .option('--output-h-data <file>', 'Write the data-h value into this file')
     .action(async (options) => {
     const projectDir = process.cwd();
-    // Resolve output
-    const outputInput = typeof options.output === 'string' && options.output.trim().length
-        ? options.output.trim()
-        : 'exported';
-    const exportDir = path.isAbsolute(outputInput)
-        ? path.resolve(outputInput)
-        : path.resolve(projectDir, outputInput);
-    const exportDirResolved = path.resolve(exportDir);
-    const exportDirRoot = path.parse(exportDirResolved).root;
+    const outputInput = (typeof options.output === 'string' && options.output.trim()) || 'exported';
+    const exportDirResolved = path.resolve(projectDir, outputInput);
     const projectDirResolved = path.resolve(projectDir);
-    if (exportDirResolved === exportDirRoot) {
-        Console.error(`Refusing to use output directory at drive root: ${exportDirResolved}`);
-        process.exit(1);
-    }
-    const relExportToProject = path.relative(projectDirResolved, exportDirResolved);
-    if (relExportToProject === '' || relExportToProject === '.' || relExportToProject.startsWith('..')) {
-        Console.error(`Refusing to export to ${exportDirResolved}. Use a subfolder like "exported" or an explicit path inside the project.`);
+    if (exportDirResolved === path.parse(exportDirResolved).root) {
+        Console.error(`Refusing to use drive root: ${exportDirResolved}`);
         process.exit(1);
     }
-    // assetsDir
-    const assetsDirInputRaw = typeof options.assetsDir === 'string' ? options.assetsDir : '.vatts';
-    const assetsDirInput = assetsDirInputRaw.trim().length ? assetsDirInputRaw.trim() : '.';
+    const assetsDirInput = (typeof options.assetsDir === 'string' && options.assetsDir.trim()) || '.vatts';
     const assetsDirResolved = path.resolve(exportDirResolved, assetsDirInput);
     const relAssetsToExport = path.relative(exportDirResolved, assetsDirResolved);
-    if (relAssetsToExport.startsWith('..') || path.isAbsolute(relAssetsToExport)) {
-        Console.error(`Invalid --assets-dir: must be inside output directory. Received: ${assetsDirInputRaw}`);
-        process.exit(1);
-    }
-    const assetsDirUrl = relAssetsToExport.split(path.sep).join('/').replace(/^\.?\/?/, '');
-    const assetsBaseHref = '/.' + (assetsDirUrl.length ? assetsDirUrl + '/' : '');
+    const assetsBaseHref = '/.' + (relAssetsToExport.split(path.sep).join('/').replace(/^\.?\/?/, '') || '');
     Console.info('Starting export process...');
     try {
-        // 1. Limpa pasta de exportação
+        let { loadVattsConfig, setConfig, config } = require("../helpers");
+        setConfig(await loadVattsConfig(projectDirResolved, 'production'));
         if (fs.existsSync(exportDirResolved)) {
             Console.info('Cleaning existing export folder...');
             fs.rmSync(exportDirResolved, { recursive: true, force: true });
         }
         fs.mkdirSync(exportDirResolved, { recursive: true });
-        // 2. Build
         Console.info('Building application...');
         const helperModule = require("../helpers");
-        // Usando dev: false para produção
         const app = helperModule.default({ dev: false, port: 3000, hostname: '0.0.0.0', framework: 'native' });
         await app.prepare();
         Console.success('Build complete.');
-        // 3. Copia JavaScript
         const distDir = path.join(projectDirResolved, '.vatts');
         if (fs.existsSync(distDir)) {
             Console.info('Copying JavaScript files...');
-            const exportDistDir = assetsDirResolved;
-            copyDirRecursive(distDir, exportDistDir);
+            copyDirRecursive(distDir, assetsDirResolved);
         }
-        // 4. Copia Public
         const publicDir = path.join(projectDirResolved, 'public');
         if (fs.existsSync(publicDir)) {
             Console.info('Copying public files...');
             copyDirRecursive(publicDir, exportDirResolved);
         }
-        // 5. Gera index.html
-        const shouldExtractHData = typeof options.outputHData === 'string' && options.outputHData.trim().length > 0;
-        const shouldRenderHtml = Boolean(options.html) || shouldExtractHData;
+        const shouldExtractHData = !!options.outputHData;
+        const shouldRenderHtml = options.html !== false || shouldExtractHData;
         if (shouldRenderHtml) {
-            const writeHtmlToDisk = Boolean(options.html);
-            if (writeHtmlToDisk) {
-                Console.info('Generating index.html...');
-            }
-            else {
-                Console.info('Rendering HTML for h-data extraction...');
-            }
+            const writeHtmlToDisk = options.html !== false;
+            Console.info(writeHtmlToDisk ? 'Generating index.html...' : 'Rendering HTML for h-data extraction...');
+            const frameWork = detectFramework(projectDirResolved);
             const { renderAsStream } = require('../renderer');
             const { loadRoutes, loadLayout, loadNotFound } = require('../router');
             const userWebDir = path.join(projectDirResolved, 'src', 'web');
             const userWebRoutesDir = path.join(userWebDir, 'routes');
+            // Recarrega rotas para garantir estado limpo
             const routes = loadRoutes(userWebRoutesDir);
             loadLayout(userWebDir);
             loadNotFound(userWebDir);
-            const rootRoute = routes.find(r => r.pattern === '/') || routes[0];
-            if (rootRoute) {
+            if (routes.length === 0) {
+                Console.warn('No routes found in src/web/routes. Skipping HTML generation.');
+            }
+            else {
+                const rootRoute = routes.find(r => r.pattern === '/') || routes[0];
+                let htmlResult = '';
                 const mockReq = {
-                    url: '/',
+                    url: rootRoute.pattern || '/',
                     method: 'GET',
                     headers: { host: 'localhost' },
                     hwebDev: false,
                     hotReloadManager: null
                 };
-                let html = '';
-                let resolveStream;
-                const streamComplete = new Promise(r => resolveStream = r);
                 const mockRes = new Writable({
                     write(chunk, encoding, callback) {
-                        html += chunk.toString();
+                        htmlResult += chunk.toString();
                         callback();
                     }
                 });
+                // Extensão do mockRes para compatibilidade com o renderer
                 mockRes.setHeader = () => { };
+                mockRes.getHeader = () => { };
                 mockRes.statusCode = 200;
-                mockRes.on('finish', () => {
-                    resolveStream();
+                mockRes.end = (chunk) => {
+                    if (chunk)
+                        htmlResult += chunk.toString();
+                    mockRes.emit('finish');
+                };
+                const streamComplete = new Promise((resolve, reject) => {
+                    mockRes.on('finish', resolve);
+                    mockRes.on('error', reject);
                 });
                 await renderAsStream({
                     req: mockReq,
@@ -234,23 +201,19 @@ program
                 });
                 await streamComplete;
                 if (shouldExtractHData) {
-                    const m = html.match(/<script\b[^>]*\bid=["']__vatts_data__["'][^>]*\bdata-h=["']([^"']*)["'][^>]*>/i);
-                    if (!m || typeof m[1] !== 'string') {
-                        throw new Error('Could not find <script id="__vatts_data__" data-h="..."> in rendered HTML.');
+                    const m = htmlResult.match(/data-h=["']([^"']*)["']/i);
+                    if (m && m[1]) {
+                        const outputHDataPath = path.resolve(projectDirResolved, options.outputHData.trim());
+                        fs.mkdirSync(path.dirname(outputHDataPath), { recursive: true });
+                        fs.writeFileSync(outputHDataPath, m[1], 'utf8');
+                        Console.success(`h-data written to: ${path.relative(projectDirResolved, outputHDataPath)}`);
                     }
-                    const hDataValue = m[1];
-                    const outputHDataPathInput = options.outputHData.trim();
-                    const outputHDataPath = path.isAbsolute(outputHDataPathInput)
-                        ? path.resolve(outputHDataPathInput)
-                        : path.resolve(projectDirResolved, outputHDataPathInput);
-                    fs.mkdirSync(path.dirname(outputHDataPath), { recursive: true });
-                    fs.writeFileSync(outputHDataPath, hDataValue, 'utf8');
-                    Console.success(`h-data written to: ${path.relative(projectDirResolved, outputHDataPath)}`);
                 }
                 if (writeHtmlToDisk) {
-                    const scriptReplaced = html.replace(/\/_vatts\//g, assetsBaseHref);
+                    // Ajusta caminhos dos scripts para serem relativos ao assetsDir
+                    const finalHtml = htmlResult.replace(/\/_vatts\//g, assetsBaseHref.endsWith('/') ? assetsBaseHref : assetsBaseHref + '/');
                     const indexPath = path.join(exportDirResolved, 'index.html');
-                    fs.writeFileSync(indexPath, scriptReplaced, 'utf8');
+                    fs.writeFileSync(indexPath, finalHtml, 'utf8');
                     Console.success('index.html generated.');
                 }
             }