vatts 1.4.1-test.1 → 1.4.1-test.2

package/dist/api/http3.d.ts

@@ -12,30 +12,51 @@ export interface ProxyOptions {
     certPath: string;
     /** Caminho para o arquivo de chave privada SSL (.pem) */
     keyPath: string;
+    /** Habilita suporte a WebTransport */
+    enableWebTransport?: boolean;
     /** (Opcional) Sobrescreve o caminho da biblioteca manualmente */
     customLibPath?: string;
 }
+/**
+ * Interface para os callbacks do WebTransport.
+ * Use isso para tipar o handler ao chamar addTransport.
+ */
+export interface WebTransportCallbacks {
+    /** Chamado quando um cliente conecta na rota */
+    onConnect?: (client: WebTransportClient) => void;
+    /** Chamado quando uma mensagem é recebida do cliente */
+    onMessage: (client: WebTransportClient, msg: string) => void;
+    /** Chamado quando a conexão é fechada */
+    onClose?: (client: WebTransportClient) => void;
+}
+export declare class WebTransportClient {
+    readonly id: string;
+    private sendFunc;
+    private closeFunc;
+    constructor(id: string, sendFunc: Function, closeFunc: Function);
+    send(data: string): void;
+    close(): void;
+}
 export declare class NativeProxy {
-    private static instance;
+    private static instanceStart;
+    private static instanceSend;
+    private static instanceClose;
+    private static transportRoutes;
+    private static activeClients;
     /**
-     * Detecta a plataforma e arquitetura para montar o nome do arquivo.
-     * Padrão esperado: vatts-proxy-{os}-{arch}.node
-     * Ex: vatts-proxy-win-x64.node
+     * Registra uma rota WebTransport.
+     * @param route Caminho da rota (ex: "/chat")
+     * @param handler Objeto com callbacks
      */
-    static getLibPath(): string;
+    static addTransportRoute(route: string, handler: WebTransportCallbacks): void;
     /**
-     * Carrega a biblioteca nativa usando Koffi.
+     * Detecta a plataforma e arquitetura para montar o nome do arquivo.
      */
+    static getLibPath(): string;
     private static loadLibrary;
-    /**
-     * Inicia o servidor Proxy.
-     * Nota: A execução no Go é assíncrona (non-blocking), então esta função retorna
-     * imediatamente após iniciar as threads do servidor, a menos que haja um erro inicial.
-     */
+    private static handleGoCallback;
     static start(options: ProxyOptions): void;
 }
-/**
- * API Pública
- */
 export declare const startProxy: (options: ProxyOptions) => void;
+export declare const addTransport: (route: string, handler: WebTransportCallbacks) => void;
 export default startProxy;

package/dist/api/http3.js

@@ -3,24 +3,55 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startProxy = exports.NativeProxy = void 0;
+exports.addTransport = exports.startProxy = exports.NativeProxy = exports.WebTransportClient = void 0;
 const koffi_1 = __importDefault(require("koffi"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
+// Wrapper para interagir com o cliente conectado via Go
+class WebTransportClient {
+    id;
+    sendFunc;
+    closeFunc;
+    constructor(id, sendFunc, closeFunc) {
+        this.id = id;
+        this.sendFunc = sendFunc;
+        this.closeFunc = closeFunc;
+    }
+    // Envia dados para o cliente (Vue)
+    send(data) {
+        this.sendFunc(this.id, data);
+    }
+    // Força o fechamento da conexão
+    close() {
+        this.closeFunc(this.id);
+    }
+}
+exports.WebTransportClient = WebTransportClient;
 class NativeProxy {
-    static instance = null;
+    static instanceStart = null;
+    static instanceSend = null;
+    static instanceClose = null;
+    // Mapa de rotas -> callbacks
+    static transportRoutes = new Map();
+    // Cache de clientes ativos para evitar recriar o objeto a cada mensagem
+    static activeClients = new Map();
+    /**
+     * Registra uma rota WebTransport.
+     * @param route Caminho da rota (ex: "/chat")
+     * @param handler Objeto com callbacks
+     */
+    static addTransportRoute(route, handler) {
+        this.transportRoutes.set(route, handler);
+    }
     /**
      * Detecta a plataforma e arquitetura para montar o nome do arquivo.
-     * Padrão esperado: vatts-proxy-{os}-{arch}.node
-     * Ex: vatts-proxy-win-x64.node
      */
     static getLibPath() {
         const platform = os_1.default.platform();
         const arch = os_1.default.arch();
         let osName = '';
-        let ext = '.node'; // Mantendo sua convenção de extensão
-        // Mapeamento de SO
+        let ext = '.node';
         switch (platform) {
             case 'win32':
                 osName = 'win';
@@ -31,10 +62,8 @@ class NativeProxy {
             case 'darwin':
                 osName = 'darwin';
                 break;
-            default:
-                throw new Error(`Sistema operacional não suportado: ${platform}`);
+            default: throw new Error(`Sistema operacional não suportado: ${platform}`);
         }
-        // Mapeamento de Arquitetura
         let archName = '';
         switch (arch) {
             case 'x64':
@@ -43,68 +72,91 @@ class NativeProxy {
             case 'arm64':
                 archName = 'arm64';
                 break;
-            default:
-                throw new Error(`Arquitetura não suportada: ${arch}`);
+            default: throw new Error(`Arquitetura não suportada: ${arch}`);
         }
         const filename = `core-${osName}-${archName}${ext}`;
-        // Ajuste o caminho relativo conforme a estrutura do seu projeto
-        // Assumindo que estará na pasta '../proxy' relativo a este arquivo
         return path_1.default.resolve(__dirname, '..', 'core-go', filename);
     }
-    /**
-     * Carrega a biblioteca nativa usando Koffi.
-     */
     static loadLibrary(customPath) {
-        if (this.instance)
-            return this.instance;
+        if (this.instanceStart)
+            return;
         const libPath = customPath || this.getLibPath();
         if (!fs_1.default.existsSync(libPath)) {
             throw new Error(`Biblioteca nativa não encontrada: ${libPath}.\n`);
         }
         try {
             const lib = koffi_1.default.load(libPath);
-            // Mapeia a função Go: StartServer
-            // Argumentos: 5 strings
-            // Retorno: string (erro) ou null (sucesso)
-            this.instance = lib.func('StartServer', 'str', ['str', 'str', 'str', 'str', 'str']);
-            return this.instance;
+            // 1. Define o callback do C (Go chama isso)
+            const OnWebTransportMessage = koffi_1.default.proto('void OnWebTransportMessage(str id, str path, str event, str data)');
+            // 2. Mapeia as funções do Go
+            this.instanceStart = lib.func('StartServer', 'str', ['str', 'str', 'str', 'str', 'str', 'str']);
+            this.instanceSend = lib.func('WebTransportSend', 'void', ['str', 'str']);
+            this.instanceClose = lib.func('WebTransportClose', 'void', ['str']);
+            const registerCallback = lib.func('RegisterWebTransportCallback', 'void', [koffi_1.default.pointer(OnWebTransportMessage)]);
+            // 3. Registra a função JS que o Go vai chamar
+            const jsCallback = (id, path, event, data) => {
+                this.handleGoCallback(id, path, event, data);
+            };
+            registerCallback(jsCallback);
         }
         catch (error) {
-            throw new Error(`Falha ao carregar a biblioteca nativa de proxy em ${libPath}: ${error}`);
+            throw new Error(`Falha ao carregar a biblioteca nativa: ${error}`);
+        }
+    }
+    static handleGoCallback(id, path, event, data) {
+        const routeHandler = this.transportRoutes.get(path);
+        // Se não tiver rota registrada, o Go vai manter a conexão aberta mas sem lógica,
+        // ou podemos fechar. Por enquanto, ignoramos.
+        if (!routeHandler)
+            return;
+        let client = this.activeClients.get(id);
+        if (!client) {
+            client = new WebTransportClient(id, this.instanceSend, this.instanceClose);
+            this.activeClients.set(id, client);
+        }
+        try {
+            if (event === 'CONNECT') {
+                if (routeHandler.onConnect)
+                    routeHandler.onConnect(client);
+            }
+            else if (event === 'MESSAGE') {
+                if (routeHandler.onMessage)
+                    routeHandler.onMessage(client, data);
+            }
+            else if (event === 'CLOSE') {
+                if (routeHandler.onClose)
+                    routeHandler.onClose(client);
+                this.activeClients.delete(id);
+            }
+        }
+        catch (e) {
+            console.error(`[Vatts WebTransport Error] Handler failed for ${path}:`, e);
         }
     }
-    /**
-     * Inicia o servidor Proxy.
-     * Nota: A execução no Go é assíncrona (non-blocking), então esta função retorna
-     * imediatamente após iniciar as threads do servidor, a menos que haja um erro inicial.
-     */
     static start(options) {
-        const { httpPort, httpsPort, backendUrl, certPath, keyPath, customLibPath } = options;
-        const startServer = this.loadLibrary(customLibPath);
-        // Resolve caminhos absolutos para evitar erros no Go
+        const { httpPort, httpsPort, backendUrl, certPath, keyPath, customLibPath, enableWebTransport } = options;
+        this.loadLibrary(customLibPath);
         const absCert = path_1.default.resolve(certPath);
         const absKey = path_1.default.resolve(keyPath);
-        // Validação básica de existência dos arquivos de certificado antes de chamar o Go
-        if (!fs_1.default.existsSync(absCert)) {
-            throw new Error(`Arquivo de certificado não encontrado: ${absCert}`);
-        }
-        if (!fs_1.default.existsSync(absKey)) {
-            throw new Error(`Arquivo de chave não encontrado: ${absKey}`);
-        }
-        // Chama a função nativa
-        const errorMsg = startServer(httpPort, httpsPort, backendUrl, absCert, absKey);
+        if (!fs_1.default.existsSync(absCert))
+            throw new Error(`Certificado não encontrado: ${absCert}`);
+        if (!fs_1.default.existsSync(absKey))
+            throw new Error(`Chave não encontrada: ${absKey}`);
+        const strWebTransport = enableWebTransport ? "true" : "false";
+        // Chama StartServer no Go
+        const errorMsg = this.instanceStart(httpPort, httpsPort, backendUrl, absCert, absKey, strWebTransport);
         if (errorMsg) {
             throw new Error(`[Vatts Proxy Error] ${errorMsg}`);
         }
     }
 }
 exports.NativeProxy = NativeProxy;
-/**
- * API Pública
- */
 const startProxy = (options) => {
     return NativeProxy.start(options);
 };
 exports.startProxy = startProxy;
-// Export padrão
+const addTransport = (route, handler) => {
+    return NativeProxy.addTransportRoute(route, handler);
+};
+exports.addTransport = addTransport;
 exports.default = exports.startProxy;

package/dist/builder.js

@@ -263,7 +263,10 @@ function getOptimizationPlugins(isProduction) {
             'process.env.NODE_ENV': JSON.stringify(env),
             'process.env': JSON.stringify({ NODE_ENV: env }),
             'process.browser': 'true',
-            '__REACT_DEVTOOLS_GLOBAL_HOOK__': '({ isDisabled: true })',
+            // [FIX] Use bracket notation string replacement.
+            // This prevents SyntaxError "window.({ isDisabled: true })"
+            // and bypasses recursive replacements by downstream plugins.
+            '__REACT_DEVTOOLS_GLOBAL_HOOK__': 'window["__REACT_DEVTOOLS_GLOBAL_HOOK__"]',
             preventAssignment: true,
             objectGuards: true
         }));
@@ -367,7 +370,8 @@ async function buildWithChunks(entryPoint, outdir, isProduction = false) {
         if (replacePlugin)
             inputOptions.plugins.unshift(replacePlugin);
         inputOptions.plugins.push(...otherPlugins);
-        const processPolyfill = `var process = { env: { NODE_ENV: "${isProduction ? 'production' : 'development'}" } };`;
+        // [FIX] Injected polyfill for React DevTools Hook to prevent ReferenceError
+        const processPolyfill = `var process = { env: { NODE_ENV: "${isProduction ? 'production' : 'development'}" } }; try { if (typeof window !== 'undefined' && typeof window.__REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') { window.__REACT_DEVTOOLS_GLOBAL_HOOK__ = { isDisabled: true }; } } catch(e) {}`;
         const outputOptions = {
             dir: outdir,
             format: 'es',
@@ -496,7 +500,8 @@ async function build(entryPoint, outfile, isProduction = false) {
         if (replacePlugin)
             inputOptions.plugins.unshift(replacePlugin);
         inputOptions.plugins.push(...otherPlugins);
-        const processPolyfill = `var process = { env: { NODE_ENV: "${isProduction ? 'production' : 'development'}" } };`;
+        // [FIX] Injected polyfill for React DevTools Hook
+        const processPolyfill = `var process = { env: { NODE_ENV: "${isProduction ? 'production' : 'development'}" } }; try { if (typeof window !== 'undefined' && typeof window.__REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') { window.__REACT_DEVTOOLS_GLOBAL_HOOK__ = { isDisabled: true }; } } catch(e) {}`;
         const outputOptions = {
             file: outfile,
             format: 'iife',
@@ -574,7 +579,8 @@ async function watchWithChunks(entryPoint, outdir, hotReloadManager = null) {
         inputOptions.external = nodeBuiltIns;
         const optimizationPlugins = getOptimizationPlugins(false);
         inputOptions.plugins = [...inputOptions.plugins, ...optimizationPlugins];
-        const processPolyfill = `var process = { env: { NODE_ENV: "development" } };`;
+        // [FIX] Injected polyfill for React DevTools Hook
+        const processPolyfill = `var process = { env: { NODE_ENV: "development" } }; try { if (typeof window !== 'undefined' && typeof window.__REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') { window.__REACT_DEVTOOLS_GLOBAL_HOOK__ = { isDisabled: true }; } } catch(e) {}`;
         const outputOptions = {
             dir: outdir,
             format: 'es',
@@ -606,7 +612,8 @@ async function watch(entryPoint, outfile, hotReloadManager = null) {
         inputOptions.external = nodeBuiltIns;
         const optimizationPlugins = getOptimizationPlugins(false);
         inputOptions.plugins = [...inputOptions.plugins, ...optimizationPlugins];
-        const processPolyfill = `var process = { env: { NODE_ENV: "development" } };`;
+        // [FIX] Injected polyfill for React DevTools Hook
+        const processPolyfill = `var process = { env: { NODE_ENV: "development" } }; try { if (typeof window !== 'undefined' && typeof window.__REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') { window.__REACT_DEVTOOLS_GLOBAL_HOOK__ = { isDisabled: true }; } } catch(e) {}`;
         const outputOptions = {
             file: outfile,
             format: 'es',

package/dist/helpers.js

@@ -66,7 +66,7 @@ const path_1 = __importDefault(require("path"));
 const index_js_1 = __importStar(require("./index.js")); // Importando o tipo
 const console_1 = __importStar(require("./api/console"));
 const fs_1 = __importDefault(require("fs"));
-const http3_1 = __importDefault(require("./api/http3"));
+const http3_1 = __importStar(require("./api/http3"));
 // Registra loaders customizados para importar arquivos não-JS
 const { registerLoaders } = require('./loaders');
 registerLoaders({ projectDir: process.cwd() });
@@ -498,8 +498,54 @@ async function initNativeServer(vattsApp, options, hostname) {
                     httpsPort: `:${publicPort}`, // Porta Principal (UDP/TCP)
                     backendUrl: `http://127.0.0.1:${backendPort}`, // Para onde enviar o tráfego
                     certPath: exports.config?.ssl?.cert,
-                    keyPath: exports.config?.ssl?.key
+                    keyPath: exports.config?.ssl?.key,
+                    enableWebTransport: true
                 });
+                // Lista de clientes conectados na sala
+                const connectedClients = new Set();
+                // Configura a rota do WebTransport
+                (0, http3_1.addTransport)('/chat', {
+                    onConnect: (client) => {
+                        console.log(`[Chat] Cliente conectado: ${client.id}`);
+                        connectedClients.add(client);
+                        // Avisa todo mundo que alguém entrou
+                        broadcast(client.id, JSON.stringify({
+                            type: 'system',
+                            text: `Usuário ${client.id.substring(0, 4)} entrou na sala.`
+                        }));
+                    },
+                    onMessage: (client, message) => {
+                        try {
+                            // O frontend manda JSON, a gente repassa pra geral
+                            console.log(`[Chat] Msg de ${client.id}: ${message}`);
+                            const payload = JSON.stringify({
+                                type: 'user',
+                                sender: client.id.substring(0, 4),
+                                text: message
+                            });
+                            broadcast(null, payload); // Null = envia para todos
+                        }
+                        catch (e) {
+                            console.error('Erro ao processar mensagem:', e);
+                        }
+                    },
+                    onClose: (client) => {
+                        console.log(`[Chat] Cliente desconectou: ${client.id}`);
+                        connectedClients.delete(client);
+                        broadcast(null, JSON.stringify({
+                            type: 'system',
+                            text: `Usuário ${client.id.substring(0, 4)} saiu.`
+                        }));
+                    }
+                });
+                // Função auxiliar para enviar mensagem para todos
+                function broadcast(senderId, msg) {
+                    for (const client of connectedClients) {
+                        // Opcional: Não enviar de volta para quem mandou (se quiser echo, remova o if)
+                        // if (senderId && client.id === senderId) continue;
+                        client.send(msg);
+                    }
+                }
                 // Atualiza o box de info para mostrar a porta pública correta
                 sendBox({ ...options });
                 msg.end(`${console_1.Colors.Bright}Ready on port ${console_1.Colors.BgGreen} ${publicPort} (HTTP/3 Enabled) ${console_1.Colors.Reset}\n` +

package/dist/index.js

@@ -534,7 +534,7 @@ function vatts(options) {
                         // Se o arquivo solicitado termina em .js e NÃO existe fisicamente (foi deletado pelo otimizador),
                         // tentamos encontrar a versão .js.gz
                         if (filePath && !fs_1.default.existsSync(filePath) && filePath.endsWith('.js')) {
-                            const gzipPath = filePath + '.gz';
+                            const gzipPath = filePath + '.br';
                             if (fs_1.default.existsSync(gzipPath)) {
                                 filePath = gzipPath;
                                 isGzipped = true;
@@ -568,7 +568,7 @@ function vatts(options) {
                             }
                             // --- HEADER VITAL PARA GZIP ---
                             if (isGzipped) {
-                                genericRes.header('Content-Encoding', 'gzip');
+                                genericRes.header('Content-Encoding', 'br');
                             }
                             const lastModified = stats.mtime.toUTCString();
                             genericRes.header('Last-Modified', lastModified);

package/dist/react/react.build.js

@@ -33,6 +33,9 @@ async function createReactConfig(entryPoint, outdir, isProduction, { prePlugins
     const replaceValues = {
         'process.env.NODE_ENV': JSON.stringify(isProduction ? 'production' : 'development'),
         'process.env.PORT': JSON.stringify(process.vatts?.port || 3000),
+        // [FIX] Define o hook do DevTools como um objeto vazio seguro caso não exista,
+        // evitando o ReferenceError em builds de produção ou ambientes restritos.
+        '__REACT_DEVTOOLS_GLOBAL_HOOK__': '({ isDisabled: true })',
         preventAssignment: true
     };
     const extensions = ['.mjs', '.js', '.json', '.node', '.jsx', '.tsx', '.ts'];
@@ -86,7 +89,9 @@ async function createReactConfig(entryPoint, outdir, isProduction, { prePlugins
                 treeShaking: true,
                 target: 'esnext',
                 jsx: 'automatic',
-                define: { __VERSION__: '"1.0.0"' },
+                define: {
+                    __VERSION__: '"1.0.0"',
+                },
                 loaders: esbuildLoaders
             })
         ],

package/dist/react/renderer-react.js

@@ -171,9 +171,9 @@ function getBuildAssets(req) {
             const fullPath = path_1.default.join(directory, file);
             const stat = fs_1.default.statSync(fullPath);
             if (stat.isFile()) {
-                // MODIFICADO: Aceita .js OU .js.gz
-                if (file.endsWith('.js') || file.endsWith('.js.gz')) {
-                    scripts.push(`${urlPrefix}/${file.replace(".gz", '')}`);
+                // MODIFICADO: Aceita .js OU .js.br
+                if (file.endsWith('.js') || file.endsWith('.js.br')) {
+                    scripts.push(`${urlPrefix}/${file.replace(".br", '')}`);
                 }
                 else if (file.endsWith('.css')) {
                     styles.push(`${urlPrefix}/${file}`);
@@ -188,9 +188,9 @@ function getBuildAssets(req) {
             const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
             const manifestFiles = Object.values(manifest);
             scripts = manifestFiles
-                // MODIFICADO: Filtra .js E .js.gz no manifesto
-                .filter((f) => f.endsWith('.js') || f.endsWith('.js.gz'))
-                .map((f) => `/_vatts/${f.replace(".gz", "")}`);
+                // MODIFICADO: Filtra .js E .js.br no manifesto
+                .filter((f) => f.endsWith('.js') || f.endsWith('.js.br'))
+                .map((f) => `/_vatts/${f.replace(".br", "")}`);
             styles = manifestFiles
                 .filter((f) => f.endsWith('.css'))
                 .map((f) => `/_vatts/${f}`);

package/dist/vue/renderer.vue.js

@@ -101,9 +101,9 @@ function extractComponentPreloads(componentPath) {
                 tags.add(`<link rel="preload" as="style" href="${publicUrl}">`);
                 tags.add(`<link rel="stylesheet" href="${publicUrl}">`);
             }
-            else if (['.js', '.js.gz'].includes(ext)) {
+            else if (['.js', '.js.br'].includes(ext)) {
                 // Adicionado suporte para JS
-                tags.add(`<link rel="preload" as="script" href="${publicUrl.replace(".gz", '')}">`);
+                tags.add(`<link rel="preload" as="script" href="${publicUrl.replace(".br", '')}">`);
             }
             else if (['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.avif'].includes(ext)) {
                 tags.add(`<link rel="preload" as="image" href="${publicUrl}">`);
@@ -331,8 +331,8 @@ function getBuildAssets(req) {
                 return;
             const fullPath = path_1.default.join(directory, file);
             if (fs_1.default.statSync(fullPath).isFile()) {
-                if (file.endsWith('.js') || file.endsWith(".js.gz"))
-                    scripts.push(`${urlPrefix}/${file.replace(".gz", '')}`);
+                if (file.endsWith('.js') || file.endsWith(".js.br"))
+                    scripts.push(`${urlPrefix}/${file.replace(".br", '')}`);
                 else if (file.endsWith('.css'))
                     styles.push(`${urlPrefix}/${file}`);
             }
@@ -343,7 +343,7 @@ function getBuildAssets(req) {
         if (fs_1.default.existsSync(manifestPath)) {
             const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
             const manifestFiles = Object.values(manifest);
-            scripts = manifestFiles.filter((f) => f.endsWith('.js') || f.endsWith(".js.gz")).map((f) => `/_vatts/${f.replace('.gz', '')}`);
+            scripts = manifestFiles.filter((f) => f.endsWith('.js') || f.endsWith(".js.br")).map((f) => `/_vatts/${f.replace('.br', '')}`);
             styles = manifestFiles.filter((f) => f.endsWith('.css')).map((f) => `/_vatts/${f}`);
         }
         else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vatts",
-  "version": "1.4.1-test.1",
+  "version": "1.4.1-test.2",
   "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": "mfraz",