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

package/dist/builder.js

@@ -15,6 +15,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 const { rollup, watch: rollupWatch } = require('rollup');
 const path = require('path');
 const Console = require("./api/console").default;
@@ -27,6 +35,28 @@ const replace = require('@rollup/plugin-replace').default;
 const esbuild = require('rollup-plugin-esbuild').default;
 const jsonPlugin = require("@rollup/plugin-json").default;
 const { loadTsConfigPaths, resolveTsConfigAlias } = require('./tsconfigPaths');
+// --- Helper de Detecção de Framework ---
+// Helper para determinar o framework principal do projeto
+function detectFramework(projectDir = process.cwd()) {
+    // 1. Tenta detectar pelo package.json (mais preciso e evita conflitos)
+    try {
+        const pkgPath = path.join(projectDir, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            // Prioridade explicita para React se estiver listado
+            if (deps.react || deps['react-dom'])
+                return 'react';
+            // Se tiver Vue e não React, é Vue
+            if (deps.vue || deps['nuxt'])
+                return 'vue';
+        }
+    }
+    catch (e) {
+        // Ignora erro de leitura
+    }
+    return 'react'; // Default fallback
+}
 const tsconfigPathsPlugin = (projectDir = process.cwd()) => {
     const info = loadTsConfigPaths(projectDir);
     return {
@@ -85,7 +115,7 @@ const customPostCssPlugin = (isProduction) => {
             try {
                 let postcss;
                 try {
-                    postcss = require(path.join(projectDir, 'node_modules', 'postcss'));
+                    postcss = require(__rewriteRelativeImportExtension(path.join(projectDir, 'node_modules', 'postcss')));
                 }
                 catch {
                     try {
@@ -96,10 +126,7 @@ const customPostCssPlugin = (isProduction) => {
                     }
                 }
                 if (postcss) {
-                    // OTIMIZAÇÃO DE RAM: Removido 'delete require.cache'.
-                    // Limpar o cache constantemente fragmenta a memória heap do V8 em processos longos (watch).
-                    // Se o usuário alterar o config, ele deve reiniciar o processo.
-                    const config = require(configPath);
+                    const config = require(__rewriteRelativeImportExtension(configPath));
                     const postcssConfig = config.default || config;
                     const plugins = [];
                     if (postcssConfig.plugins) {
@@ -108,10 +135,10 @@ const customPostCssPlugin = (isProduction) => {
                                 if (typeof p === 'string') {
                                     try {
                                         const resolved = require.resolve(p, { paths: [projectDir] });
-                                        return require(resolved);
+                                        return require(__rewriteRelativeImportExtension(resolved));
                                     }
                                     catch {
-                                        return require(p);
+                                        return require(__rewriteRelativeImportExtension(p));
                                     }
                                 }
                                 return p;
@@ -121,7 +148,7 @@ const customPostCssPlugin = (isProduction) => {
                             for (const [name, options] of Object.entries(postcssConfig.plugins)) {
                                 try {
                                     const resolvedPath = require.resolve(name, { paths: [projectDir] });
-                                    const pluginModule = require(resolvedPath);
+                                    const pluginModule = require(__rewriteRelativeImportExtension(resolvedPath));
                                     plugins.push(pluginModule(options || {}));
                                 }
                                 catch (e) {
@@ -142,73 +169,55 @@ const customPostCssPlugin = (isProduction) => {
     };
     return {
         name: 'custom-postcss-plugin',
-        async resolveId(source, importer) {
-            if (source.startsWith('\0custom-css:'))
+        async transform(code, id) {
+            // Intercepta arquivos CSS e requests virtuais de estilo do Vue (que terminam em .css)
+            if (!id.endsWith('.css'))
                 return null;
-            if (source.endsWith('.css')) {
-                const resolution = await this.resolve(source, importer, { skipSelf: true });
-                if (resolution && resolution.id) {
-                    if (resolution.id.startsWith('\0custom-css:'))
-                        return resolution.id;
-                    return `\0custom-css:${resolution.id}`;
-                }
-            }
-            return null;
-        },
-        async load(id) {
-            if (id.startsWith('\0custom-css:')) {
-                let filePath = id.slice('\0custom-css:'.length);
-                while (filePath.startsWith('\0custom-css:')) {
-                    filePath = filePath.slice('\0custom-css:'.length);
+            const processor = await initPostCss(process.cwd());
+            let processedCss = code;
+            if (processor) {
+                try {
+                    const result = await processor.process(code, {
+                        from: id,
+                        to: id,
+                        map: false // Mapas inline ou não, melhor manter simples aqui
+                    });
+                    processedCss = result.css;
                 }
-                const cssContent = await fs.promises.readFile(filePath, 'utf8');
-                // Usa o processador em cache ou inicializa se for a primeira vez
-                const processor = await initPostCss(process.cwd());
-                let processedCss = cssContent;
-                if (processor) {
-                    try {
-                        const result = await processor.process(cssContent, {
-                            from: filePath,
-                            to: filePath
-                        });
-                        processedCss = result.css;
-                    }
-                    catch (e) {
-                        Console.warn(`PostCSS process error:`, e.message);
-                    }
+                catch (e) {
+                    Console.warn(`PostCSS process error:`, e.message);
                 }
-                // OTIMIZAÇÃO: Emite arquivo físico sempre que possível.
-                // Strings gigantes de CSS inline consomem muita RAM no bundle JS.
-                const referenceId = this.emitFile({
-                    type: 'asset',
-                    name: path.basename(filePath),
-                    source: processedCss
-                });
-                // Lógica unificada: Usa arquivo externo tanto em Dev quanto Prod.
-                // Isso libera a memória que seria usada para stringificar o CSS dentro do JS.
-                // FIX: O Rollup pode retornar um objeto URL ao invés de string. String() força a conversão.
-                return `
-                    const cssUrl = String(import.meta.ROLLUP_FILE_URL_${referenceId});
-                    if (typeof document !== 'undefined') {
-                        const link = document.createElement('link');
-                        link.rel = 'stylesheet';
-                        link.href = cssUrl;
-                        document.head.appendChild(link);
-                    }
-                    export default cssUrl;
-                `;
             }
-            return null;
+            // Emite o arquivo CSS processado como asset
+            // Remove query params do Vue (ex: ?vue&type=style...) para gerar um nome de arquivo limpo
+            const cleanName = path.basename(id).split('?')[0];
+            const referenceId = this.emitFile({
+                type: 'asset',
+                name: cleanName,
+                source: processedCss
+            });
+            // Retorna o módulo JS que injeta o CSS via <link>
+            // FIX: Retorna um objeto com 'code' e 'map' para evitar o aviso "Sourcemap is likely to be incorrect"
+            return {
+                code: `
+                const cssUrl = String(import.meta.ROLLUP_FILE_URL_${referenceId});
+                if (typeof document !== 'undefined') {
+                    const link = document.createElement('link');
+                    link.rel = 'stylesheet';
+                    link.href = cssUrl;
+                    document.head.appendChild(link);
+                }
+                export default cssUrl;
+            `,
+                map: { mappings: '' }
+            };
         }
     };
 };
 /**
  * Plugin Inteligente para Assets (Otimizado para RAM)
- * - Agora utiliza emissão de arquivos também em DEV para arquivos grandes.
  */
 const smartAssetPlugin = (isProduction) => {
-    // 4KB - Arquivos maiores que isso viram referência externa.
-    // Manter isso baixo economiza MUITA RAM, pois evita strings Base64 gigantes no JS.
     const INLINE_LIMIT = 4096;
     return {
         name: 'smart-asset-loader',
@@ -231,19 +240,17 @@ const smartAssetPlugin = (isProduction) => {
             const type = mimeTypes[ext];
             if (!type)
                 return null;
-            // Text files always strings (geralmente pequenos)
             if (type === 'txt') {
                 const content = await fs.promises.readFile(cleanId, 'utf8');
                 return `export default ${JSON.stringify(content)};`;
             }
             let buffer = await fs.promises.readFile(cleanId);
             const size = buffer.length;
-            // Tratamento especial para SVG (inline SVG vs URL)
             if (type === 'svg') {
                 if (size < INLINE_LIMIT) {
                     const content = buffer.toString('utf8');
                     const base64 = buffer.toString('base64');
-                    buffer = null; // GC Hint
+                    buffer = null;
                     return `
                         export default "data:image/svg+xml;base64,${base64}";
                         export const svgContent = ${JSON.stringify(content)};
@@ -256,21 +263,16 @@ const smartAssetPlugin = (isProduction) => {
                         source: buffer
                     });
                     const content = buffer.toString('utf8');
-                    buffer = null; // GC Hint
-                    // FIX: O Rollup pode retornar um objeto URL. String() resolve o erro de startsWith.
+                    buffer = null;
                     return `
                         export default String(import.meta.ROLLUP_FILE_URL_${referenceId});
                         export const svgContent = ${JSON.stringify(content)};
                     `;
                 }
             }
-            // Para outros assets:
-            // Se for pequeno, Base64 (reduz requests HTTP)
-            // Se for grande, Arquivo (reduz uso de RAM e tamanho do bundle JS)
-            // Essa lógica agora aplica para DEV e PROD. Base64 em Dev para arquivos grandes era o vilão da RAM.
             if (size < INLINE_LIMIT) {
                 const base64 = buffer.toString('base64');
-                buffer = null; // Libera memória do buffer bruto imediatamente
+                buffer = null;
                 return `export default "data:${type};base64,${base64}";`;
             }
             else {
@@ -279,69 +281,155 @@ const smartAssetPlugin = (isProduction) => {
                     name: path.basename(cleanId),
                     source: buffer
                 });
-                buffer = null; // Libera memória
-                // FIX: O Rollup pode retornar um objeto URL. String() resolve o erro de startsWith.
+                buffer = null;
                 return `export default String(import.meta.ROLLUP_FILE_URL_${referenceId});`;
             }
         }
     };
 };
 /**
- * Gera a configuração base do Rollup
+ * Gera a configuração base do Rollup (Agora Async e Estrita)
  */
-function createRollupConfig(entryPoint, outdir, isProduction) {
+async function createRollupConfig(entryPoint, outdir, isProduction) {
+    // Detecta Framework de forma exclusiva e robusta
+    const framework = detectFramework();
+    const hasVue = framework === 'vue';
+    const hasReact = framework === 'react';
+    // Define variáveis de ambiente
+    const replaceValues = {
+        'process.env.NODE_ENV': JSON.stringify(isProduction ? 'production' : 'development'),
+        'process.env.PORT': JSON.stringify(process.vatts.port || 3000)
+    };
+    // --- LÓGICA VUE ESTRITA ---
+    let vuePlugin = null;
+    if (hasVue) {
+        replaceValues['__VUE_OPTIONS_API__'] = JSON.stringify(true);
+        replaceValues['__VUE_PROD_DEVTOOLS__'] = JSON.stringify(!isProduction);
+        try {
+            let vuePkg;
+            try {
+                vuePkg = require('rollup-plugin-vue');
+            }
+            catch (e) {
+                if (e.code === 'ERR_REQUIRE_ESM') {
+                    vuePkg = await import('rollup-plugin-vue');
+                }
+                else {
+                    throw e;
+                }
+            }
+            const vueFactory = vuePkg.default || vuePkg;
+            if (typeof vueFactory === 'function') {
+                vuePlugin = vueFactory({
+                    compilerOptions: {
+                        isCustomElement: (tag) => tag.includes('-')
+                    }
+                });
+            }
+        }
+        catch (e) {
+            Console.warn("Vue detected but failed to load rollup-plugin-vue:", e.message);
+        }
+    }
+    // --- CONFIGURAÇÃO DE EXTENSÕES ---
+    // Fix: Prioriza .vue se for um projeto Vue para evitar que o NodeResolve pegue artefatos gerados (como .vue.js do Volar)
+    // ao invés do arquivo fonte .vue.
+    let extensions = ['.mjs', '.js', '.json', '.node', '.jsx', '.tsx', '.ts'];
+    if (hasVue) {
+        // Coloca .vue no INÍCIO da lista
+        extensions = ['.vue', ...extensions];
+    }
+    // --- CONFIGURAÇÃO DO ESBUILD ---
+    // SEPARAÇÃO: Regex específico para cada framework.
+    // FIX ERRO VUE: O Regex do Vue inclui os arquivos virtuais `?vue`,
+    // mas o loader '.vue': 'ts' foi removido para evitar conflito com o plugin do Vue.
+    let esbuildInclude;
+    if (hasVue) {
+        esbuildInclude = /\.[jt]sx?$|\.vue\?vue/;
+    }
+    else {
+        esbuildInclude = /\.[jt]sx?$/; // React/Vanilla: ignora arquivos virtuais do Vue
+    }
+    const esbuildLoaders = {
+        '.js': 'jsx',
+        '.ts': 'ts',
+        '.tsx': 'tsx',
+        // RESTAURADO: .vue para ts. Isso é NECESSÁRIO para processar blocos <script lang="ts">
+        // Se houver erros do tipo __VLS_, o plugin 'block-volar-artifacts' abaixo deve resolver.
+        '.vue': 'ts'
+    };
+    // No Vue, partes do arquivo podem virar TS, mas isso é pego pela extensão do arquivo virtual,
+    // não precisamos forçar no loader geral.
     return {
         input: entryPoint,
         external: nodeBuiltIns,
-        // Otimização: Treeshake limpa memória removendo nós da AST não usados
         treeshake: {
-            moduleSideEffects: 'no-external', // Mais agressivo, economiza memória
+            moduleSideEffects: 'no-external',
             preset: isProduction ? 'recommended' : 'smallest'
         },
-        // Cache desativado em DEV conforme solicitado anteriormente,
-        // o que ajuda na RAM pois não mantém a AST antiga em memória.
         cache: isProduction ? true : false,
         perf: false,
-        // Limita execuções paralelas de leitura de arquivo internas do Rollup
         maxParallelFileOps: 20,
         plugins: [
             replace({
                 preventAssignment: true,
-                values: {
-                    'process.env.NODE_ENV': JSON.stringify(isProduction ? 'production' : 'development'),
-                    'proccess.env.PORT': JSON.stringify(process.vatts.port || 3000)
-                }
+                values: replaceValues
             }),
             tsconfigPathsPlugin(process.cwd()),
+            // NOVO: Blocker agressivo para artefatos gerados pelo Volar/TS (.vue.js, .vue.d.ts)
+            // Isso previne que o build tente empacotar arquivos temporários de tipagem como se fossem código fonte.
+            {
+                name: 'block-volar-artifacts',
+                load(id) {
+                    // Ignora arquivos que terminam em .vue.js, .vue.ts, ou .vue.d.ts
+                    // Esses arquivos frequentemente contêm código "virtual" (__VLS_...) que causa erros em runtime.
+                    if (/\.vue\.(js|ts|d\.ts|map)$/.test(id)) {
+                        return 'export default {};';
+                    }
+                    return null;
+                }
+            },
+            // NOVO: Blocker para artefatos Vue (.vue e .vue.js) em projetos React
+            // Impede que arquivos compilados do Vue quebrem o build React
+            {
+                name: 'block-vue-artifacts',
+                load(id) {
+                    // Verifica se não estamos no Vue e se o arquivo é um artefato Vue
+                    if (!hasVue && (id.endsWith('.vue') || id.endsWith('.vue.js'))) {
+                        // Retorna módulo vazio para "matar" o arquivo e impedir erros de runtime
+                        return 'export default {};';
+                    }
+                    return null;
+                }
+            },
             nodeResolve({
-                extensions: ['.mjs', '.js', '.json', '.node', '.jsx', '.tsx', '.ts'],
+                extensions, // Agora com .vue prioritário se hasVue for true
                 preferBuiltins: true,
                 browser: true,
-                dedupe: ['react', 'react-dom']
+                dedupe: hasReact ? ['react', 'react-dom'] : (hasVue ? ['vue'] : [])
             }),
+            // CRÍTICO: Injeta plugin do Vue APENAS se for Vue e ANTES de commonjs/esbuild.
+            ...(hasVue && vuePlugin ? [vuePlugin] : []),
             commonjs({
                 sourceMap: !isProduction,
                 requireReturnsDefault: 'auto',
-                // Ignora try-catch dinâmicos para economizar análise
                 ignoreTryCatch: true
             }),
             markdownPlugin(),
-            // PostCSS Otimizado
             customPostCssPlugin(isProduction),
-            // Assets Otimizados (menos Base64)
             smartAssetPlugin(isProduction),
             jsonPlugin(),
             esbuild({
-                include: /\.[jt]sx?$/,
-                exclude: /node_modules/,
+                include: esbuildInclude,
+                exclude: /node_modules/, // Se for React, arquivos .vue serão ignorados pelo regex do include
                 sourceMap: !isProduction,
                 minify: isProduction,
-                legalComments: 'none', // Remove comentários para limpar buffer
+                legalComments: 'none',
                 treeShaking: isProduction,
-                target: isProduction ? 'es2020' : 'esnext',
+                target: 'esnext',
                 jsx: 'automatic',
                 define: { __VERSION__: '"1.0.0"' },
-                loaders: { '.js': 'jsx' }
+                loaders: esbuildLoaders
             })
         ],
         onwarn(warning, warn) {
@@ -349,7 +437,6 @@ function createRollupConfig(entryPoint, outdir, isProduction) {
                 return;
             if (warning.code === 'THIS_IS_UNDEFINED')
                 return;
-            // Ignora avisos circulares comuns que enchem o log/buffer
             if (warning.code === 'CIRCULAR_DEPENDENCY' && warning.message.includes('node_modules'))
                 return;
             warn(warning);
@@ -362,7 +449,7 @@ function createRollupConfig(entryPoint, outdir, isProduction) {
 async function buildWithChunks(entryPoint, outdir, isProduction = false) {
     await cleanDirectoryExcept(outdir, 'temp');
     try {
-        const inputOptions = createRollupConfig(entryPoint, outdir, isProduction);
+        const inputOptions = await createRollupConfig(entryPoint, outdir, isProduction);
         const outputOptions = {
             dir: outdir,
             format: 'es',
@@ -370,7 +457,6 @@ async function buildWithChunks(entryPoint, outdir, isProduction = false) {
             chunkFileNames: 'chunks/[name]-[hash].js',
             assetFileNames: 'assets/[name]-[hash][extname]',
             sourcemap: !isProduction,
-            // Compacta output para economizar memória de escrita
             compact: isProduction,
             manualChunks(id) {
                 if (id.includes('node_modules')) {
@@ -378,7 +464,10 @@ async function buildWithChunks(entryPoint, outdir, isProduction = false) {
                     if (/\/node_modules\/(react|react-dom|scheduler|prop-types|loose-envify|object-assign)\//.test(normalizedId)) {
                         return 'vendor-react';
                     }
-                    if (id.includes('framer-motion') || id.includes('@radix-ui')) {
+                    if (/\/node_modules\/(vue|@vue)\//.test(normalizedId)) {
+                        return 'vendor-vue';
+                    }
+                    if (id.includes('framer-motion') || id.includes('@radix-ui') || id.includes('@headlessui')) {
                         return 'vendor-ui';
                     }
                     if (id.includes('lodash') || id.includes('date-fns') || id.includes('axios')) {
@@ -390,7 +479,7 @@ async function buildWithChunks(entryPoint, outdir, isProduction = false) {
         };
         const bundle = await rollup(inputOptions);
         await bundle.write(outputOptions);
-        await bundle.close(); // Importante fechar para liberar memória
+        await bundle.close();
     }
     catch (error) {
         Console.error('An error occurred while building with chunks:', error);
@@ -404,14 +493,14 @@ async function build(entryPoint, outfile, isProduction = false) {
     const outdir = path.dirname(outfile);
     await cleanDirectoryExcept(outdir, 'temp');
     try {
-        const inputOptions = createRollupConfig(entryPoint, outdir, isProduction);
+        const inputOptions = await createRollupConfig(entryPoint, outdir, isProduction);
         const outputOptions = {
             file: outfile,
             format: 'iife',
             name: 'Vattsjs',
             sourcemap: !isProduction,
             inlineDynamicImports: true,
-            compact: true // Ajuda na RAM
+            compact: true
         };
         const bundle = await rollup(inputOptions);
         await bundle.write(outputOptions);
@@ -433,7 +522,6 @@ function handleWatcherEvents(watcher, hotReloadManager, resolveFirstBuild) {
         if (event.code === 'START') {
             currentBuildId += 1;
             lastStartedBuildId = currentBuildId;
-            // Dica pro V8 limpar lixo antes de começar um build pesado
             if (global.gc) {
                 try {
                     global.gc();
@@ -460,7 +548,6 @@ function handleWatcherEvents(watcher, hotReloadManager, resolveFirstBuild) {
                 resolveFirstBuild();
         }
         if (event.code === 'BUNDLE_END') {
-            // CRÍTICO: Fechar o bundle libera a memória dos módulos
             event.result.close();
         }
         if (event.code === 'END') {
@@ -488,7 +575,7 @@ function handleWatcherEvents(watcher, hotReloadManager, resolveFirstBuild) {
 async function watchWithChunks(entryPoint, outdir, hotReloadManager = null) {
     await cleanDirectoryExcept(outdir, 'temp');
     try {
-        const inputOptions = createRollupConfig(entryPoint, outdir, false);
+        const inputOptions = await createRollupConfig(entryPoint, outdir, false);
         const outputOptions = {
             dir: outdir,
             format: 'es',
@@ -502,7 +589,6 @@ async function watchWithChunks(entryPoint, outdir, hotReloadManager = null) {
                 exclude: 'node_modules/**',
                 clearScreen: false,
                 skipWrite: false,
-                // Atraso curto para evitar múltiplos rebuilds rápidos que comem CPU/RAM
                 buildDelay: 100
             }
         };
@@ -523,7 +609,7 @@ async function watchWithChunks(entryPoint, outdir, hotReloadManager = null) {
 async function watch(entryPoint, outfile, hotReloadManager = null) {
     const outdir = path.dirname(outfile);
     try {
-        const inputOptions = createRollupConfig(entryPoint, outdir, false);
+        const inputOptions = await createRollupConfig(entryPoint, outdir, false);
         const outputOptions = {
             file: outfile,
             format: 'es',
@@ -555,9 +641,6 @@ async function cleanDirectoryExcept(dirPath, excludeFolder) {
             return;
         const excludes = Array.isArray(excludeFolder) ? excludeFolder : [excludeFolder];
         const items = await readdir(dirPath);
-        // OTIMIZAÇÃO: Loop sequencial ao invés de Promise.all.
-        // Promise.all é mais rápido, mas cria dezenas/centenas de Promises simultâneas na RAM.
-        // O loop sequencial é mais gentil com o Garbage Collector.
         for (const item of items) {
             if (excludes.includes(item))
                 continue;
@@ -567,7 +650,7 @@ async function cleanDirectoryExcept(dirPath, excludeFolder) {
                 await rm(itemPath, { recursive: info.isDirectory(), force: true });
             }
             catch (e) {
-                // Ignora erro se arquivo sumir durante o loop
+                // Ignora erro se arquivo sumir
             }
         }
     }

package/dist/client/clientRouter.js

@@ -18,8 +18,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.router = exports.Router = void 0;
 class Router {
+    listeners = new Set();
     constructor() {
-        this.listeners = new Set();
         // Só adiciona listener no lado do cliente
         if (typeof window !== 'undefined') {
             window.addEventListener('popstate', () => {