versacompiler 2.4.1 → 2.5.0

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

@@ -0,0 +1,218 @@
+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

package/dist/compiler/pipeline/module-graph.js

@@ -0,0 +1,63 @@
+export class ModuleGraph {
+    nodes = new Map();
+    getNode(id) {
+        return this.nodes.get(id);
+    }
+    ensureNode(id) {
+        const existing = this.nodes.get(id);
+        if (existing)
+            return existing;
+        const node = {
+            id,
+            importers: new Set(),
+            imports: new Set(),
+            lastUpdated: Date.now(),
+        };
+        this.nodes.set(id, node);
+        return node;
+    }
+    updateImports(id, imports) {
+        const node = this.ensureNode(id);
+        node.imports.clear();
+        for (const dep of imports) {
+            node.imports.add(dep);
+            const depNode = this.ensureNode(dep);
+            depNode.importers.add(id);
+        }
+        node.lastUpdated = Date.now();
+    }
+    invalidate(id) {
+        const invalidated = new Set();
+        const queue = [id];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (invalidated.has(current))
+                continue;
+            invalidated.add(current);
+            const node = this.nodes.get(current);
+            if (!node)
+                continue;
+            for (const importer of node.importers) {
+                queue.push(importer);
+            }
+        }
+        return Array.from(invalidated);
+    }
+    remove(id) {
+        const node = this.nodes.get(id);
+        if (!node)
+            return;
+        for (const dep of node.imports) {
+            const depNode = this.nodes.get(dep);
+            if (depNode)
+                depNode.importers.delete(id);
+        }
+        for (const importer of node.importers) {
+            const importerNode = this.nodes.get(importer);
+            if (importerNode)
+                importerNode.imports.delete(id);
+        }
+        this.nodes.delete(id);
+    }
+}
+//# sourceMappingURL=module-graph.js.map

package/dist/compiler/pipeline/plugin-driver.js

@@ -0,0 +1,87 @@
+export class PluginDriver {
+    plugins;
+    constructor(plugins) {
+        this.plugins = plugins;
+    }
+    async resolve(args) {
+        for (const plugin of this.plugins) {
+            if (!plugin.onResolve)
+                continue;
+            const result = await plugin.onResolve(args);
+            if (result && (result.path || result.external || result.errors)) {
+                return result;
+            }
+        }
+        return {};
+    }
+    async load(args) {
+        for (const plugin of this.plugins) {
+            if (!plugin.onLoad)
+                continue;
+            const result = await plugin.onLoad(args);
+            if (result && (result.contents || result.errors)) {
+                return result;
+            }
+        }
+        return {};
+    }
+    async transform(args) {
+        let current = args.contents;
+        let currentLoader = args.loader;
+        let currentMeta = args.meta;
+        let errors = [];
+        for (const plugin of this.plugins) {
+            if (!plugin.onTransform)
+                continue;
+            const result = await plugin.onTransform({
+                ...args,
+                contents: current,
+                loader: currentLoader,
+                meta: currentMeta,
+            });
+            if (result.errors?.length)
+                errors = errors.concat(result.errors);
+            if (result.contents)
+                current = result.contents;
+            if (result.loader)
+                currentLoader = result.loader;
+            if (result.meta)
+                currentMeta = {
+                    ...(currentMeta || {}),
+                    ...result.meta,
+                };
+        }
+        return {
+            contents: current,
+            loader: currentLoader,
+            meta: currentMeta,
+            errors: errors.length ? errors : undefined,
+        };
+    }
+    async hotUpdate(args) {
+        let reload = 'none';
+        let errors = [];
+        for (const plugin of this.plugins) {
+            if (!plugin.onHotUpdate)
+                continue;
+            const result = await plugin.onHotUpdate(args);
+            if (result.errors?.length)
+                errors = errors.concat(result.errors);
+            if (result.reload === 'full')
+                reload = 'full';
+            if (result.reload === 'module' && reload !== 'full')
+                reload = 'module';
+        }
+        return { reload, errors: errors.length ? errors : undefined };
+    }
+    async end(errors) {
+        const args = { errors };
+        for (const plugin of this.plugins) {
+            if (!plugin.onEnd)
+                continue;
+            await plugin.onEnd(args);
+        }
+        return { errors };
+    }
+}
+//# sourceMappingURL=plugin-driver.js.map

package/dist/compiler/pipeline/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/compiler/transforms.js

@@ -90,7 +90,9 @@ function isExternalModule(moduleRequest, pathAlias) {
         return true;
     } // Descartar alias conocidos
     for (const alias of Object.keys(pathAlias)) {
-        const aliasPattern = alias.replace('/*', '');
+        // Quitar solo el '*' final para conservar el separador '/'
+        // Ejemplo: '@/*' → '@/', así '@vueuse/core' no hace match pero '@/foo' sí
+        const aliasPattern = alias.replace('*', '');
         if (moduleRequest.startsWith(aliasPattern)) {
             return false;
         }
@@ -105,6 +107,211 @@ function isExternalModule(moduleRequest, pathAlias) {
     // Si llegamos aquí, es probablemente un módulo externo
     return true;
 }
+async function resolveModuleRequest(moduleRequest, file, pathAlias) {
+    let newPath = null;
+    let transformed = false;
+    if (!transformed && isExternalModule(moduleRequest, pathAlias)) {
+        try {
+            const optimizedResult = await getOptimizedModulePath(moduleRequest, file);
+            if (optimizedResult.excluded) {
+                return null;
+            }
+            if (optimizedResult.path) {
+                newPath = optimizedResult.path;
+                transformed = true;
+            }
+            else {
+                const modulePath = getModuleSubPath(moduleRequest, file);
+                if (modulePath === null) {
+                    return null;
+                }
+                if (modulePath) {
+                    newPath = modulePath;
+                    transformed = true;
+                }
+            }
+        }
+        catch (error) {
+            if (env.VERBOSE === 'true')
+                logger.warn(`Error resolviendo módulo ${moduleRequest}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (!transformed) {
+        const aliasPath = getOptimizedAliasPath(moduleRequest);
+        if (aliasPath) {
+            let newImportPath = aliasPath;
+            if (newImportPath.endsWith('.ts') ||
+                newImportPath.endsWith('.vue')) {
+                newImportPath = newImportPath.replace(/\.(ts|vue)$/, '.js');
+            }
+            else if (!/\.(js|mjs|css|json)$/.test(newImportPath)) {
+                newImportPath += '.js';
+            }
+            newPath = newImportPath;
+            transformed = true;
+        }
+        else {
+            for (const [alias] of Object.entries(pathAlias)) {
+                const aliasPattern = alias.replace('*', '');
+                if (moduleRequest.startsWith(aliasPattern)) {
+                    const relativePath = moduleRequest.replace(aliasPattern, '');
+                    let newImportPath = path.join('/', env.PATH_DIST, relativePath);
+                    newImportPath = newImportPath
+                        .replace(/\/\.\//g, '/')
+                        .replace(/\\/g, '/');
+                    if (newImportPath.endsWith('.ts') ||
+                        newImportPath.endsWith('.vue')) {
+                        newImportPath = newImportPath.replace(/\.(ts|vue)$/, '.js');
+                    }
+                    else if (!/\.(js|mjs|css|json)$/.test(newImportPath)) {
+                        newImportPath += '.js';
+                    }
+                    newPath = newImportPath;
+                    transformed = true;
+                    break;
+                }
+            }
+        }
+    }
+    if (!transformed &&
+        (moduleRequest.startsWith('./') || moduleRequest.startsWith('../'))) {
+        let relativePath = moduleRequest;
+        if (relativePath.endsWith('.ts') || relativePath.endsWith('.vue')) {
+            relativePath = relativePath.replace(/\.(ts|vue)$/, '.js');
+            newPath = relativePath;
+            transformed = true;
+        }
+        else if (!/\.(js|mjs|css|json)$/.test(relativePath)) {
+            newPath = relativePath + '.js';
+            transformed = true;
+        }
+    }
+    return transformed ? newPath : null;
+}
+function extractLiteralValue(raw) {
+    if (!raw || raw.length < 2)
+        return null;
+    const quote = raw[0];
+    const last = raw[raw.length - 1];
+    if ((quote !== '"' && quote !== "'" && quote !== '`') || last !== quote) {
+        return null;
+    }
+    if (quote === '`' && raw.includes('${')) {
+        return null;
+    }
+    return { quote, value: raw.slice(1, -1) };
+}
+function resolveAliasTemplateLiteral(raw, pathAlias) {
+    if (!raw.startsWith('`'))
+        return null;
+    const exprIndex = raw.indexOf('${');
+    if (exprIndex === -1)
+        return null;
+    const prefix = raw.slice(1, exprIndex);
+    if (!prefix)
+        return null;
+    const sortedAliases = Object.entries(pathAlias).sort((a, b) => {
+        const aliasA = a[0].replace('/*', '');
+        const aliasB = b[0].replace('/*', '');
+        return aliasB.length - aliasA.length;
+    });
+    for (const [alias, target] of sortedAliases) {
+        const aliasPattern = alias.replace('/*', '');
+        if (!prefix.startsWith(aliasPattern))
+            continue;
+        const relativePath = prefix.replace(aliasPattern, '');
+        const targetArray = Array.isArray(target) ? target : [target];
+        const targetPath = targetArray[0];
+        if (!targetPath)
+            continue;
+        let newPrefix;
+        if (targetPath.startsWith('/')) {
+            newPrefix = path.join('/', env.PATH_DIST, relativePath);
+        }
+        else {
+            const cleanTarget = targetPath.replace('./', '').replace('/*', '');
+            const normalizedPathDist = env.PATH_DIST.replace('./', '');
+            if (cleanTarget === normalizedPathDist) {
+                newPrefix = path.join('/', normalizedPathDist, relativePath);
+            }
+            else {
+                newPrefix = path.join('/', normalizedPathDist, cleanTarget, relativePath);
+            }
+        }
+        newPrefix = newPrefix
+            .replace(/\/\.\//g, '/')
+            .replace(/\\/g, '/')
+            .replace(/\/+/g, '/');
+        return `\`${newPrefix}${raw.slice(exprIndex)}`;
+    }
+    return null;
+}
+async function replaceAliasImportsAst(code, file, ast) {
+    if (!env.PATH_ALIAS || !env.PATH_DIST) {
+        return code;
+    }
+    const pathAlias = getParsedPathAlias();
+    if (!pathAlias)
+        return code;
+    const replacements = [];
+    const staticImports = ast?.module?.staticImports || [];
+    for (const item of staticImports) {
+        const moduleRequest = item?.moduleRequest?.value;
+        const start = item?.moduleRequest?.start;
+        const end = item?.moduleRequest?.end;
+        if (typeof moduleRequest !== 'string')
+            continue;
+        if (typeof start !== 'number' || typeof end !== 'number')
+            continue;
+        const newPath = await resolveModuleRequest(moduleRequest, file, pathAlias);
+        if (!newPath || newPath === moduleRequest)
+            continue;
+        const raw = code.slice(start, end);
+        const literal = extractLiteralValue(raw);
+        if (!literal)
+            continue;
+        replacements.push({
+            start,
+            end,
+            value: `${literal.quote}${newPath}${literal.quote}`,
+        });
+    }
+    const dynamicImports = ast?.module?.dynamicImports || [];
+    for (const item of dynamicImports) {
+        const start = item?.moduleRequest?.start;
+        const end = item?.moduleRequest?.end;
+        if (typeof start !== 'number' || typeof end !== 'number')
+            continue;
+        const raw = code.slice(start, end);
+        const literal = extractLiteralValue(raw);
+        if (!literal) {
+            const replaced = resolveAliasTemplateLiteral(raw, pathAlias);
+            if (replaced) {
+                replacements.push({ start, end, value: replaced });
+            }
+            continue;
+        }
+        const newPath = await resolveModuleRequest(literal.value, file, pathAlias);
+        if (!newPath || newPath === literal.value)
+            continue;
+        replacements.push({
+            start,
+            end,
+            value: `${literal.quote}${newPath}${literal.quote}`,
+        });
+    }
+    if (replacements.length === 0)
+        return code;
+    replacements.sort((a, b) => b.start - a.start);
+    let resultCode = code;
+    for (const replacement of replacements) {
+        resultCode =
+            resultCode.slice(0, replacement.start) +
+                replacement.value +
+                resultCode.slice(replacement.end);
+    }
+    return resultCode;
+}
 export async function replaceAliasImportStatic(file, code) {
     if (!env.PATH_ALIAS || !env.PATH_DIST) {
         return code;
@@ -124,13 +331,13 @@ export async function replaceAliasImportStatic(file, code) {
         if (!transformed && isExternalModule(moduleRequest, pathAlias)) {
             try {
                 // Usar el sistema optimizado primero
-                const optimizedPath = await getOptimizedModulePath(moduleRequest, file);
-                if (optimizedPath === null) {
-                    // Si el optimizador retorna null, significa que es un módulo excluido
+                const optimizedResult = await getOptimizedModulePath(moduleRequest, file);
+                if (optimizedResult.excluded) {
+                    // Módulo excluido explícitamente: mantener importación original
                     continue;
                 }
-                if (optimizedPath) {
-                    newPath = optimizedPath;
+                if (optimizedResult.path) {
+                    newPath = optimizedResult.path;
                     transformed = true;
                 }
                 else {
@@ -169,7 +376,7 @@ export async function replaceAliasImportStatic(file, code) {
             else {
                 // Fallback al sistema anterior
                 for (const [alias] of Object.entries(pathAlias)) {
-                    const aliasPattern = alias.replace('/*', '');
+                    const aliasPattern = alias.replace('*', '');
                     if (moduleRequest.startsWith(aliasPattern)) {
                         // Reemplazar el alias con la ruta del target
                         const relativePath = moduleRequest.replace(aliasPattern, '');
@@ -239,13 +446,13 @@ export async function replaceAliasImportDynamic(code, _imports, file) {
         if (!transformed && isExternalModule(moduleRequest, pathAlias)) {
             try {
                 // Usar el sistema optimizado primero
-                const optimizedPath = await getOptimizedModulePath(moduleRequest, file);
-                if (optimizedPath === null) {
-                    // Si el optimizador retorna null, significa que es un módulo excluido
+                const optimizedResult = await getOptimizedModulePath(moduleRequest, file);
+                if (optimizedResult.excluded) {
+                    // Módulo excluido explícitamente: mantener importación original
                     continue;
                 }
-                if (optimizedPath) {
-                    newPath = optimizedPath;
+                if (optimizedResult.path) {
+                    newPath = optimizedResult.path;
                     transformed = true;
                 }
                 else {
@@ -284,7 +491,7 @@ export async function replaceAliasImportDynamic(code, _imports, file) {
             else {
                 // Fallback al sistema anterior
                 for (const [alias] of Object.entries(pathAlias)) {
-                    const aliasPattern = alias.replace('/*', '');
+                    const aliasPattern = alias.replace('*', '');
                     if (moduleRequest.startsWith(aliasPattern)) {
                         // Reemplazar el alias con la ruta del target
                         const relativePath = moduleRequest.replace(aliasPattern, '');
@@ -356,7 +563,7 @@ export async function replaceAliasImportDynamic(code, _imports, file) {
         // 2. Verificar aliases en template literals
         if (!transformed) {
             for (const [alias] of Object.entries(pathAlias)) {
-                const aliasPattern = alias.replace('/*', '');
+                const aliasPattern = alias.replace('*', '');
                 if (moduleRequest.includes(aliasPattern)) {
                     const relativePath = moduleRequest.replace(aliasPattern, '');
                     // Para alias que apuntan a la raíz (como @/* -> /src/*),
@@ -550,8 +757,7 @@ export async function estandarizaCode(code, file) {
             const firstError = ast.errors[0];
             throw new Error(firstError?.message || 'Error sin mensaje');
         }
-        code = await replaceAliasImportStatic(file, code);
-        code = await replaceAliasImportDynamic(code, ast?.module.dynamicImports, file);
+        code = await replaceAliasImportsAst(code, file, ast);
         code = await replaceAliasInStrings(code);
         code = await removehtmlOfTemplateString(code);
         code = await removeCodeTagImport(code);

package/dist/compiler/typescript-manager.js

@@ -55,7 +55,9 @@ export const loadTypeScriptConfig = (fileName) => {
         }
         catch (error) {
             console.warn(`[loadTypeScriptConfig] Error cargando ${configPath}:`, error);
-            throw new Error(`No se puede continuar sin un tsconfig.json válido. Error: ${error}`, { cause: error });
+            throw new Error(`No se puede continuar sin un tsconfig.json válido. Error: ${error}`, {
+                cause: error,
+            });
         }
         // ✨ FIX #9: Guardar en cache con timestamp
         configCache = {