versacompiler 2.4.1 → 2.6.0

package/dist/compiler/module-resolution-optimizer.js

@@ -1,3 +1,15 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
 /**
  * Module Resolution Optimizer
  *
@@ -14,6 +26,7 @@ import { dirname, join, relative } from 'node:path';
 import { cwd, env } from 'node:process';
 import { logger } from '../servicios/logger.js';
 import { EXCLUDED_MODULES } from '../utils/excluded-modules.js';
+import { parseModuleSpecifier, resolveExportValue, } from '../utils/module-resolver.js';
 /**
  * Sistema de optimización de resolución de módulos
  * Implementa indexación, caché y búsquedas O(1)
@@ -122,7 +135,7 @@ export class ModuleResolutionOptimizer {
             for (const entry of entries) {
                 const modulePath = join(nodeModulesPath, entry);
                 try {
-                    if (entry.startsWith('/dist/examples')) {
+                    if (entry.startsWith('/dist/public')) {
                         // Scoped packages
                         const scopedModules = readdirSync(modulePath);
                         this.metrics.filesystemAccess++;
@@ -207,10 +220,7 @@ export class ModuleResolutionOptimizer {
                     entryPoint = dotExport;
                 }
                 else if (typeof dotExport === 'object') {
-                    entryPoint =
-                        dotExport.import ||
-                            dotExport.browser ||
-                            dotExport.default;
+                    entryPoint = resolveExportValue(dotExport);
                 }
             }
         }
@@ -420,7 +430,9 @@ export class ModuleResolutionOptimizer {
             this.aliasIndex = [];
             // Convertir alias a índice con prioridad
             for (const [alias, target] of Object.entries(pathAlias)) {
-                const pattern = alias.replace('/*', '');
+                // Quitar solo el '*' final para conservar el separador '/'
+                // Ejemplo: '@/*' → '@/', así '@vueuse/core' no hace match pero '@/foo' sí
+                const pattern = alias.replace('*', '');
                 const priority = pattern.length; // Patrones más largos tienen prioridad
                 // El regex debe coincidir con el patrón al inicio, seguido de cualquier cosa o fin de cadena
                 // Por ejemplo, para "@/" debe coincidir con "@/cualquier-cosa" o solo "@/"
@@ -453,6 +465,7 @@ export class ModuleResolutionOptimizer {
                 path: null,
                 cached: false,
                 resolveTime: performance.now() - startTime,
+                excluded: true,
             };
         }
         // Crear clave de caché
@@ -472,13 +485,16 @@ export class ModuleResolutionOptimizer {
         // Resolver módulo
         let resolvedPath = null;
         try {
-            // 1. Verificar si es subpath de módulo (ej: 'vue/dist/vue.esm-bundler')
-            if (moduleName.includes('/')) {
+            // 1. Parse specifier to correctly handle scoped packages
+            const { packageName, subPath } = parseModuleSpecifier(moduleName);
+            if (subPath) {
+                // Has a real subpath (e.g. 'vue/dist/x' or '@scope/pkg/sub')
                 resolvedPath = await this.resolveSubPath(moduleName);
             }
             else {
+                // Direct package (e.g. 'vue' or '@vueuse/core')
                 // 2. Búsqueda O(1) en el índice
-                resolvedPath = this.resolveFromIndex(moduleName);
+                resolvedPath = this.resolveFromIndex(packageName);
             }
             // 3. Si no se encuentra en índice, intentar resolución tradicional
             if (!resolvedPath) {
@@ -521,8 +537,7 @@ export class ModuleResolutionOptimizer {
      * Resuelve subpaths de módulos (ej: 'vue/dist/vue.esm-bundler')
      */
     async resolveSubPath(moduleName) {
-        const [packageName, ...subPathParts] = moduleName.split('/');
-        const subPath = subPathParts.join('/');
+        const { packageName, subPath } = parseModuleSpecifier(moduleName);
         if (!packageName) {
             return null;
         }
@@ -531,19 +546,19 @@ export class ModuleResolutionOptimizer {
         if (!moduleInfo) {
             return null;
         }
+        // If no subPath, resolve as direct package
+        if (!subPath) {
+            const entryPoint = moduleInfo.optimizedEntry || moduleInfo.entryPoint;
+            return join(moduleInfo.fullPath, entryPoint);
+        }
         // Verificar exports field para subpaths
         if (moduleInfo.hasExports && moduleInfo.packageJson.exports) {
             const exportKey = `./${subPath}`;
             const exportPath = moduleInfo.packageJson.exports[exportKey];
             if (exportPath) {
-                if (typeof exportPath === 'string') {
-                    return join(moduleInfo.fullPath, exportPath);
-                }
-                else if (typeof exportPath === 'object') {
-                    const importPath = exportPath.import || exportPath.default;
-                    if (typeof importPath === 'string') {
-                        return join(moduleInfo.fullPath, importPath);
-                    }
+                const resolved = resolveExportValue(exportPath);
+                if (resolved) {
+                    return join(moduleInfo.fullPath, resolved);
                 }
             }
         }
@@ -872,7 +887,7 @@ export class ModuleResolutionOptimizer {
 export async function getOptimizedModulePath(moduleName, fromFile) {
     const optimizer = ModuleResolutionOptimizer.getInstance();
     const result = await optimizer.resolveModule(moduleName, fromFile);
-    return result.path;
+    return { path: result.path, excluded: result.excluded === true };
 }
 export function getOptimizedAliasPath(path) {
     const optimizer = ModuleResolutionOptimizer.getInstance();

package/dist/compiler/parser.js

@@ -1,3 +1,15 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
 import { createHash } from 'node:crypto';
 import { statSync } from 'node:fs';
 import { open, readFile } from 'node:fs/promises';

package/dist/compiler/performance-monitor.js

@@ -1,3 +1,15 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
 /**
  * Performance Monitor - Sistema centralizado de monitoreo de optimizaciones
  * Reúne todas las métricas de cache y performance del VersaCompiler
@@ -85,67 +97,67 @@ export class PerformanceMonitor {
             const i = Math.floor(Math.log(bytes) / Math.log(k));
             return (parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]);
         };
-        const report = `
-🚀 VERSACOMPILER PERFORMANCE REPORT
-=====================================
-
-📊 RESUMEN GENERAL
-Hit Rate Total: ${stats.summary.overallHitRate}%
-Cache Hits: ${stats.summary.totalCacheHits}
-Cache Misses: ${stats.summary.totalCacheMisses}
-Memoria Total: ${formatBytes(stats.summary.totalMemoryUsage)}
-Entradas Cache: ${stats.summary.totalCacheEntries}
-
-🎯 VUE HMR CACHE
-Size: ${stats.vueHMRCache.size}/${stats.vueHMRCache.maxSize}
-TTL: ${Math.round(stats.vueHMRCache.ttl / 1000 / 60)}min
-
-📝 PARSER AST CACHE
-Hit Rate: ${stats.parserCache.hitRate}%
-Cache Hits: ${stats.parserCache.cacheHits}
-Cache Misses: ${stats.parserCache.cacheMisses}
-Size: ${stats.parserCache.cacheSize}/${stats.parserCache.maxCacheSize}
-Memoria: ${formatBytes(stats.parserCache.memoryUsage)}/${formatBytes(stats.parserCache.maxMemoryUsage)}
-
-📖 FILE CONTENT CACHE
-Hit Rate: ${stats.fileContentCache.hitRate}%
-Cache Hits: ${stats.fileContentCache.cacheHits}
-Cache Misses: ${stats.fileContentCache.cacheMisses}
-Size: ${stats.fileContentCache.cacheSize}/${stats.fileContentCache.maxCacheSize}
-
-🌐 BROWSERSYNC FILE CACHE
-Hit Rate: ${stats.browserSyncCache.hitRate}%
-Cache Hits: ${stats.browserSyncCache.cacheHits}
-Cache Misses: ${stats.browserSyncCache.cacheMisses}
-Size: ${stats.browserSyncCache.cacheSize}/${stats.browserSyncCache.maxCacheSize}
-Memoria: ${formatBytes(stats.browserSyncCache.memoryUsage)}/${formatBytes(stats.browserSyncCache.maxMemoryUsage)}
-
-🗜️ MINIFICATION CACHE
-Hit Rate: ${stats.minificationCache.hitRate}%
-Cache Hits: ${stats.minificationCache.cacheHits}
-Cache Misses: ${stats.minificationCache.cacheMisses}
-Size: ${stats.minificationCache.cacheSize}/${stats.minificationCache.maxCacheSize}
-Memoria: ${formatBytes(stats.minificationCache.memoryUsage)}/${formatBytes(stats.minificationCache.maxMemoryUsage)}
-Compresión Promedio: ${stats.minificationCache.avgCompressionRatio}%
-
-🔄 TRANSFORM OPTIMIZER
-Hit Rate: ${stats.transformOptimizer.hitRate}%
-Cache Hits: ${stats.transformOptimizer.cacheHits}
-Cache Misses: ${stats.transformOptimizer.cacheMisses}
-Transformaciones: ${stats.transformOptimizer.totalTransforms}
-Size: ${stats.transformOptimizer.cacheSize}
-Memoria: ${formatBytes(stats.transformOptimizer.memoryUsage)}
-
-📦 MODULE RESOLUTION
-Hit Rate: ${stats.moduleResolution.cacheHitRate?.toFixed(1)}%
-Cache Hits: ${stats.moduleResolution.cacheHits}
-Cache Misses: ${stats.moduleResolution.cacheMisses}
-Resoluciones: ${stats.moduleResolution.totalResolutions}
-Índice Módulos: ${stats.moduleResolution.moduleIndexSize}
-Índice Alias: ${stats.moduleResolution.aliasIndexSize}
-Tiempo Promedio: ${stats.moduleResolution.averageResolveTime?.toFixed(2)}ms
-
-=====================================
+        const report = `
+🚀 VERSACOMPILER PERFORMANCE REPORT
+=====================================
+
+📊 RESUMEN GENERAL
+Hit Rate Total: ${stats.summary.overallHitRate}%
+Cache Hits: ${stats.summary.totalCacheHits}
+Cache Misses: ${stats.summary.totalCacheMisses}
+Memoria Total: ${formatBytes(stats.summary.totalMemoryUsage)}
+Entradas Cache: ${stats.summary.totalCacheEntries}
+
+🎯 VUE HMR CACHE
+Size: ${stats.vueHMRCache.size}/${stats.vueHMRCache.maxSize}
+TTL: ${Math.round(stats.vueHMRCache.ttl / 1000 / 60)}min
+
+📝 PARSER AST CACHE
+Hit Rate: ${stats.parserCache.hitRate}%
+Cache Hits: ${stats.parserCache.cacheHits}
+Cache Misses: ${stats.parserCache.cacheMisses}
+Size: ${stats.parserCache.cacheSize}/${stats.parserCache.maxCacheSize}
+Memoria: ${formatBytes(stats.parserCache.memoryUsage)}/${formatBytes(stats.parserCache.maxMemoryUsage)}
+
+📖 FILE CONTENT CACHE
+Hit Rate: ${stats.fileContentCache.hitRate}%
+Cache Hits: ${stats.fileContentCache.cacheHits}
+Cache Misses: ${stats.fileContentCache.cacheMisses}
+Size: ${stats.fileContentCache.cacheSize}/${stats.fileContentCache.maxCacheSize}
+
+🌐 BROWSERSYNC FILE CACHE
+Hit Rate: ${stats.browserSyncCache.hitRate}%
+Cache Hits: ${stats.browserSyncCache.cacheHits}
+Cache Misses: ${stats.browserSyncCache.cacheMisses}
+Size: ${stats.browserSyncCache.cacheSize}/${stats.browserSyncCache.maxCacheSize}
+Memoria: ${formatBytes(stats.browserSyncCache.memoryUsage)}/${formatBytes(stats.browserSyncCache.maxMemoryUsage)}
+
+🗜️ MINIFICATION CACHE
+Hit Rate: ${stats.minificationCache.hitRate}%
+Cache Hits: ${stats.minificationCache.cacheHits}
+Cache Misses: ${stats.minificationCache.cacheMisses}
+Size: ${stats.minificationCache.cacheSize}/${stats.minificationCache.maxCacheSize}
+Memoria: ${formatBytes(stats.minificationCache.memoryUsage)}/${formatBytes(stats.minificationCache.maxMemoryUsage)}
+Compresión Promedio: ${stats.minificationCache.avgCompressionRatio}%
+
+🔄 TRANSFORM OPTIMIZER
+Hit Rate: ${stats.transformOptimizer.hitRate}%
+Cache Hits: ${stats.transformOptimizer.cacheHits}
+Cache Misses: ${stats.transformOptimizer.cacheMisses}
+Transformaciones: ${stats.transformOptimizer.totalTransforms}
+Size: ${stats.transformOptimizer.cacheSize}
+Memoria: ${formatBytes(stats.transformOptimizer.memoryUsage)}
+
+📦 MODULE RESOLUTION
+Hit Rate: ${stats.moduleResolution.cacheHitRate?.toFixed(1)}%
+Cache Hits: ${stats.moduleResolution.cacheHits}
+Cache Misses: ${stats.moduleResolution.cacheMisses}
+Resoluciones: ${stats.moduleResolution.totalResolutions}
+Índice Módulos: ${stats.moduleResolution.moduleIndexSize}
+Índice Alias: ${stats.moduleResolution.aliasIndexSize}
+Tiempo Promedio: ${stats.moduleResolution.averageResolveTime?.toFixed(2)}ms
+
+=====================================
         `;
         return report;
     }

package/dist/compiler/pipeline/build-pipeline.js

@@ -0,0 +1,139 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
+import { stat } from 'node:fs/promises';
+import path from 'node:path';
+import { parser } from '../parser.js';
+import { ModuleGraph } from './module-graph.js';
+import { PluginDriver } from './plugin-driver.js';
+function guessLoader(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.vue')
+        return 'vue';
+    if (ext === '.ts')
+        return 'ts';
+    if (ext === '.json')
+        return 'json';
+    if (ext === '.css')
+        return 'css';
+    return 'js';
+}
+function getAstType(loader) {
+    return loader === 'ts' ? 'ts' : 'js';
+}
+function collectModuleRequests(ast) {
+    const requests = [];
+    const staticImports = ast?.module?.staticImports || [];
+    for (const item of staticImports) {
+        const value = item?.moduleRequest?.value;
+        if (typeof value === 'string')
+            requests.push(value);
+    }
+    const dynamicImports = ast?.module?.dynamicImports || [];
+    for (const item of dynamicImports) {
+        const value = item?.moduleRequest?.value;
+        if (typeof value === 'string')
+            requests.push(value);
+    }
+    return requests;
+}
+async function resolveLocalImport(importer, specifier) {
+    if (!specifier.startsWith('.') && !specifier.startsWith('/'))
+        return null;
+    const base = specifier.startsWith('/')
+        ? path.normalize(specifier)
+        : path.resolve(path.dirname(importer), specifier);
+    const ext = path.extname(base);
+    if (ext)
+        return base;
+    const candidates = [
+        `${base}.ts`,
+        `${base}.js`,
+        `${base}.vue`,
+        `${base}.mjs`,
+        `${base}.cjs`,
+        `${base}.json`,
+        path.join(base, 'index.ts'),
+        path.join(base, 'index.js'),
+        path.join(base, 'index.vue'),
+    ];
+    for (const candidate of candidates) {
+        try {
+            await stat(candidate);
+            return candidate;
+        }
+        catch {
+            continue;
+        }
+    }
+    return base;
+}
+export class BuildPipeline {
+    driver;
+    graph;
+    constructor(plugins) {
+        this.driver = new PluginDriver(plugins);
+        this.graph = new ModuleGraph();
+    }
+    getModuleGraph() {
+        return this.graph;
+    }
+    async hotUpdate(args) {
+        return this.driver.hotUpdate(args);
+    }
+    async compileFile(filePath) {
+        const resolved = await this.driver.resolve({
+            path: filePath,
+            kind: 'entry',
+        });
+        const entryPath = resolved.path || filePath;
+        const loaded = await this.driver.load({ path: entryPath });
+        const loadErrors = loaded.errors || [];
+        if (!loaded.contents) {
+            await this.driver.end(loadErrors);
+            return {
+                code: '',
+                loader: guessLoader(entryPath),
+                dependencies: [],
+                errors: loadErrors,
+            };
+        }
+        const transformResult = await this.driver.transform({
+            path: entryPath,
+            contents: loaded.contents,
+            loader: loaded.loader || guessLoader(entryPath),
+            meta: loaded.meta,
+        });
+        const transformErrors = transformResult.errors || [];
+        const finalCode = transformResult.contents || '';
+        const finalLoader = transformResult.loader || loaded.loader || guessLoader(entryPath);
+        const ast = await parser(entryPath, finalCode, getAstType(finalLoader));
+        const requests = collectModuleRequests(ast);
+        const resolvedDeps = [];
+        for (const request of requests) {
+            const resolvedDep = await resolveLocalImport(entryPath, request);
+            if (resolvedDep)
+                resolvedDeps.push(resolvedDep);
+        }
+        this.graph.updateImports(entryPath, resolvedDeps);
+        const errors = loadErrors.concat(transformErrors);
+        await this.driver.end(errors);
+        return {
+            code: finalCode,
+            loader: finalLoader,
+            meta: transformResult.meta || loaded.meta,
+            dependencies: resolvedDeps,
+            errors,
+        };
+    }
+}
+//# sourceMappingURL=build-pipeline.js.map

package/dist/compiler/pipeline/core-plugins.js

@@ -0,0 +1,230 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
+import path from 'node:path';
+import { env } from 'node:process';
+import { logger } from '../../servicios/logger.js';
+import { CompileWorkerPool } from '../compile-worker-pool.js';
+let preCompileVue;
+let preCompileTS;
+let estandarizaCode;
+let minifyJS;
+let getCodeFile;
+let compileWorkerPool = null;
+async function loadVue() {
+    if (!preCompileVue) {
+        const mod = await import('../vuejs.js');
+        preCompileVue = mod.preCompileVue;
+    }
+    return preCompileVue;
+}
+async function loadTypeScript() {
+    if (!preCompileTS) {
+        const mod = await import('../typescript-manager.js');
+        preCompileTS = mod.preCompileTS;
+    }
+    return preCompileTS;
+}
+async function loadTransforms() {
+    if (!estandarizaCode) {
+        const mod = await import('../transforms.js');
+        estandarizaCode = mod.estandarizaCode;
+    }
+    return estandarizaCode;
+}
+async function loadMinify() {
+    if (!minifyJS) {
+        const mod = await import('../minify.js');
+        minifyJS = mod.minifyJS;
+    }
+    return minifyJS;
+}
+async function loadParser() {
+    if (!getCodeFile) {
+        const mod = await import('../parser.js');
+        getCodeFile = mod.getCodeFile;
+    }
+    return getCodeFile;
+}
+function getWorkerPool() {
+    if (!compileWorkerPool) {
+        compileWorkerPool = CompileWorkerPool.getInstance();
+    }
+    return compileWorkerPool;
+}
+function guessLoader(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.vue')
+        return 'vue';
+    if (ext === '.ts')
+        return 'ts';
+    if (ext === '.json')
+        return 'json';
+    if (ext === '.css')
+        return 'css';
+    return 'js';
+}
+function withStageError(stage, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `${stage}: ${message}`;
+}
+export function createCorePlugins() {
+    const loadPlugin = {
+        name: 'core-load',
+        async onLoad(args) {
+            try {
+                const read = await loadParser();
+                const result = await read(args.path);
+                if (result.error) {
+                    return {
+                        errors: [withStageError('file-read', result.error)],
+                    };
+                }
+                return {
+                    contents: result.code,
+                    loader: guessLoader(args.path),
+                };
+            }
+            catch (error) {
+                return { errors: [withStageError('file-read', error)] };
+            }
+        },
+    };
+    const vuePlugin = {
+        name: 'core-vue',
+        async onTransform(args) {
+            if (args.loader !== 'vue')
+                return {};
+            try {
+                const useWorkers = env.WORKER_COMPILE === 'true';
+                const result = useWorkers
+                    ? await getWorkerPool().runTask('vue', {
+                        fileName: args.path,
+                        source: args.contents,
+                        isProd: env.isPROD === 'true',
+                    })
+                    : await (await loadVue())(args.contents, args.path, env.isPROD === 'true');
+                if (result?.error) {
+                    return {
+                        errors: [withStageError('vue', result.error)],
+                    };
+                }
+                return {
+                    contents: result.data || '',
+                    loader: result.lang === 'ts' ? 'ts' : 'js',
+                    meta: {
+                        vueScriptInfo: result.scriptInfo,
+                        vueScriptLang: result.lang,
+                    },
+                };
+            }
+            catch (error) {
+                return { errors: [withStageError('vue', error)] };
+            }
+        },
+    };
+    const tsPlugin = {
+        name: 'core-ts',
+        async onTransform(args) {
+            const isTsFile = args.loader === 'ts';
+            const vueLang = args.meta?.vueScriptLang;
+            if (!isTsFile && vueLang !== 'ts')
+                return {};
+            try {
+                const useWorkers = env.WORKER_COMPILE === 'true';
+                const result = useWorkers
+                    ? await getWorkerPool().runTask('ts', {
+                        fileName: args.path,
+                        source: args.contents,
+                        scriptInfo: args.meta?.vueScriptInfo,
+                    })
+                    : await (await loadTypeScript())(args.contents, args.path, args.meta?.vueScriptInfo);
+                if (result?.error) {
+                    return {
+                        errors: [withStageError('typescript', result.error)],
+                    };
+                }
+                return {
+                    contents: result.data || '',
+                    loader: 'js',
+                };
+            }
+            catch (error) {
+                return { errors: [withStageError('typescript', error)] };
+            }
+        },
+    };
+    const transformPlugin = {
+        name: 'core-transforms',
+        async onTransform(args) {
+            try {
+                const transform = await loadTransforms();
+                const result = await transform(args.contents, args.path);
+                if (result?.error) {
+                    return {
+                        errors: [
+                            withStageError('standardization', result.error),
+                        ],
+                    };
+                }
+                return { contents: result.code || '' };
+            }
+            catch (error) {
+                return { errors: [withStageError('standardization', error)] };
+            }
+        },
+    };
+    const minifyPlugin = {
+        name: 'core-minify',
+        async onTransform(args) {
+            if (env.isPROD !== 'true')
+                return {};
+            try {
+                const useWorkers = env.WORKER_COMPILE === 'true';
+                const result = useWorkers
+                    ? await getWorkerPool().runTask('minify', {
+                        fileName: args.path,
+                        source: args.contents,
+                    })
+                    : await (await loadMinify())(args.contents, args.path, true);
+                if (result?.error) {
+                    return {
+                        errors: [withStageError('minification', result.error)],
+                    };
+                }
+                return { contents: result.code || '' };
+            }
+            catch (error) {
+                return { errors: [withStageError('minification', error)] };
+            }
+        },
+    };
+    const logPlugin = {
+        name: 'core-log',
+        onEnd(args) {
+            if (!args.errors.length)
+                return;
+            if (env.VERBOSE === 'true') {
+                logger.warn(`Pipeline errores: ${args.errors.length}`);
+            }
+        },
+    };
+    return [
+        loadPlugin,
+        vuePlugin,
+        tsPlugin,
+        transformPlugin,
+        minifyPlugin,
+        logPlugin,
+    ];
+}
+//# sourceMappingURL=core-plugins.js.map