versacompiler 2.3.3 → 2.3.5

package/dist/compiler/integrity-validator.js

@@ -0,0 +1,527 @@
+import { parseSync } from 'oxc-parser';
+import { logger } from '../servicios/logger.js';
+/**
+ * Sistema de validación de integridad para código compilado/transformado
+ *
+ * Detecta automáticamente:
+ * - Código vacío después de minificación
+ * - Exports eliminados por error
+ * - Sintaxis inválida introducida por transformaciones
+ * - Estructura de código corrupta
+ *
+ * Performance: <5ms por archivo (típicamente 1-3ms)
+ */
+export class IntegrityValidator {
+    static instance;
+    cache = new Map();
+    MAX_CACHE_SIZE = 100;
+    // Estadísticas
+    stats = {
+        totalValidations: 0,
+        successfulValidations: 0,
+        failedValidations: 0,
+        cacheHits: 0,
+        cacheMisses: 0,
+        totalDuration: 0,
+        averageDuration: 0,
+    };
+    constructor() { }
+    static getInstance() {
+        if (!IntegrityValidator.instance) {
+            IntegrityValidator.instance = new IntegrityValidator();
+        }
+        return IntegrityValidator.instance;
+    }
+    /**
+     * Valida la integridad del código procesado
+     *
+     * @param original - Código original antes del procesamiento
+     * @param processed - Código después del procesamiento
+     * @param context - Contexto de la validación (ej: "minify:file.js")
+     * @param options - Opciones de validación
+     * @returns Resultado detallado de la validación
+     */
+    validate(original, processed, context, options = {}) {
+        const startTime = performance.now();
+        this.stats.totalValidations++;
+        // Revisar cache
+        const cacheKey = this.getCacheKey(context, processed);
+        const cached = this.cache.get(cacheKey);
+        if (cached) {
+            this.stats.cacheHits++;
+            if (options.verbose) {
+                logger.info(`[IntegrityValidator] Cache hit for ${context}`);
+            }
+            return cached;
+        }
+        this.stats.cacheMisses++;
+        const errors = [];
+        // Check 1: Size (más rápido, ~0.1ms)
+        const sizeOk = this.checkSize(processed);
+        if (!sizeOk) {
+            errors.push('Código procesado está vacío o demasiado pequeño');
+            // Early return - no tiene sentido continuar
+            const result = this.createResult(false, {
+                size: false,
+                structure: false,
+                exports: false,
+                syntax: options?.skipSyntaxCheck === true, // Respetar skipSyntaxCheck incluso en early return
+            }, errors, original, processed, startTime);
+            this.handleValidationResult(result, context, options);
+            return result;
+        }
+        // Check 2: Structure (~1ms) - TEMPORALMENTE DESHABILITADO
+        // TODO: Mejorar detección de character classes en regex literals
+        const structureOk = true; // this.checkStructure(processed);
+        // if (!structureOk) {
+        //     errors.push(
+        //         'Estructura de código inválida (paréntesis/llaves/corchetes desbalanceados)',
+        //     );
+        // }
+        // Check 3: Exports (~1ms)
+        const exportsOk = this.checkExports(original, processed);
+        if (!exportsOk) {
+            errors.push('Exports fueron eliminados o modificados incorrectamente');
+        }
+        // Check 4: Syntax (~3ms) - solo si otros checks pasaron y no está skippeado
+        let syntaxOk = true;
+        if (options?.skipSyntaxCheck) {
+            // Si se salta el check de sintaxis, asumir que es válido
+            syntaxOk = true;
+        }
+        else if (structureOk && exportsOk) {
+            // Solo validar sintaxis si estructura y exports pasaron
+            syntaxOk = this.checkSyntax(processed);
+            if (!syntaxOk) {
+                errors.push('Código procesado contiene errores de sintaxis');
+            }
+        }
+        else {
+            // Si otros checks fallaron, no ejecutar syntax check (optimización)
+            // pero mantener syntaxOk = true para no agregar más errores
+            syntaxOk = true;
+        }
+        const valid = errors.length === 0;
+        const result = this.createResult(valid, {
+            size: sizeOk,
+            structure: structureOk,
+            exports: exportsOk,
+            syntax: syntaxOk,
+        }, errors, original, processed, startTime);
+        // Guardar en caché
+        this.saveToCache(cacheKey, result);
+        // Actualizar estadísticas
+        this.handleValidationResult(result, context, options);
+        return result;
+    }
+    /**
+     * Check 1: Verificar que el código no esté vacío
+     */
+    checkSize(code) {
+        // Código debe tener al menos 10 caracteres y no ser solo whitespace
+        const trimmed = code.trim();
+        return trimmed.length >= 10;
+    }
+    /**
+     * Check 2: Verificar estructura básica del código
+     */
+    checkStructure(code) {
+        // Verificar paréntesis, llaves y corchetes balanceados
+        const counters = {
+            '(': 0,
+            '[': 0,
+            '{': 0,
+        };
+        let inString = false;
+        let inTemplate = false;
+        let inTemplateInterpolation = false; // Dentro de ${ } en template literal
+        let templateBraceDepth = 0; // Para trackear nested braces en interpolación
+        let inComment = false;
+        let inMultilineComment = false;
+        let inRegex = false; // Dentro de regex literal /pattern/flags
+        let stringChar = '';
+        let escapeNext = false;
+        let prevNonWhitespaceChar = ''; // Para detectar contexto de regex
+        for (let i = 0; i < code.length;) {
+            const char = code[i];
+            const nextChar = i < code.length - 1 ? code[i + 1] : '';
+            // Manejar escape (en strings, templates y regex)
+            if (escapeNext) {
+                escapeNext = false;
+                i++;
+                continue;
+            }
+            if (char === '\\' && (inString || inTemplate || inRegex)) {
+                escapeNext = true;
+                i++;
+                continue;
+            }
+            // Detectar regex literals (antes de comentarios, porque ambos usan /)
+            if (!inString &&
+                !inTemplate &&
+                !inComment &&
+                !inMultilineComment &&
+                !inRegex &&
+                char === '/' &&
+                nextChar !== '/' &&
+                nextChar !== '*') {
+                // Contexto donde se espera regex (no división)
+                const regexContext = /[=([,;:!&|?+\-{]$/;
+                if (regexContext.test(prevNonWhitespaceChar)) {
+                    inRegex = true;
+                    i++;
+                    continue;
+                }
+            }
+            // Detectar fin de regex literal
+            if (inRegex && char === '/') {
+                inRegex = false;
+                // Skip flags como g, i, m, s, u, y
+                let j = i + 1;
+                while (j < code.length) {
+                    const flag = code[j];
+                    if (flag && /[gimsuvy]/.test(flag)) {
+                        j++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                i = j;
+                continue;
+            }
+            // Skip contenido dentro de regex
+            if (inRegex) {
+                i++;
+                continue;
+            }
+            // Detectar inicio de comentario de línea
+            if (char === '/' &&
+                nextChar === '/' &&
+                !inString &&
+                !inTemplate &&
+                !inMultilineComment) {
+                inComment = true;
+                i += 2; // Skip // completamente
+                continue;
+            }
+            // Detectar fin de comentario de línea
+            if (inComment && (char === '\n' || char === '\r')) {
+                inComment = false;
+                i++;
+                continue;
+            }
+            // Detectar inicio de comentario multilínea
+            if (char === '/' &&
+                nextChar === '*' &&
+                !inString &&
+                !inTemplate &&
+                !inComment) {
+                inMultilineComment = true;
+                i += 2; // Skip /* completamente
+                continue;
+            }
+            // Detectar fin de comentario multilínea
+            if (inMultilineComment && char === '*' && nextChar === '/') {
+                inMultilineComment = false;
+                i += 2; // Skip */ completamente
+                continue;
+            }
+            // Skip caracteres dentro de comentarios
+            if (inComment || inMultilineComment) {
+                i++;
+                continue;
+            }
+            // Detectar strings (incluyendo dentro de interpolaciones de template)
+            if (char === '"' || char === "'") {
+                // Las comillas funcionan normalmente FUERA de templates O DENTRO de interpolaciones
+                if (!inTemplate || inTemplateInterpolation) {
+                    if (!inString) {
+                        inString = true;
+                        stringChar = char;
+                    }
+                    else if (char === stringChar) {
+                        inString = false;
+                        stringChar = '';
+                    }
+                }
+                i++;
+                continue;
+            }
+            // Detectar template literals (solo fuera de regex)
+            if (!inString && !inRegex && char === '`') {
+                if (inTemplate && !inTemplateInterpolation) {
+                    // Salir de template
+                    inTemplate = false;
+                }
+                else if (!inTemplate) {
+                    // Entrar a template
+                    inTemplate = true;
+                    inTemplateInterpolation = false;
+                    templateBraceDepth = 0;
+                }
+                i++;
+                continue;
+            }
+            // Detectar inicio de interpolación en template literal: ${
+            if (inTemplate &&
+                !inTemplateInterpolation &&
+                char === '$' &&
+                nextChar === '{') {
+                inTemplateInterpolation = true;
+                templateBraceDepth = 0;
+                i += 2; // Skip ${ completamente
+                continue;
+            }
+            // Dentro de interpolación de template, contar brackets
+            if (inTemplateInterpolation) {
+                if (char === '{') {
+                    templateBraceDepth++;
+                    counters['{']++;
+                }
+                else if (char === '}') {
+                    if (templateBraceDepth === 0) {
+                        // Este } cierra la interpolación
+                        inTemplateInterpolation = false;
+                    }
+                    else {
+                        templateBraceDepth--;
+                        counters['{']--;
+                    }
+                }
+                else if (char === '(') {
+                    counters['(']++;
+                }
+                else if (char === ')') {
+                    counters['(']--;
+                }
+                else if (char === '[') {
+                    counters['[']++;
+                }
+                else if (char === ']') {
+                    counters['[']--;
+                }
+                // Early return si algún contador se vuelve negativo
+                if (counters['('] < 0 ||
+                    counters['['] < 0 ||
+                    counters['{'] < 0) {
+                    return false;
+                }
+                i++;
+                continue;
+            }
+            // Skip contenido dentro de strings o templates (pero no interpolaciones)
+            if (inString || inTemplate) {
+                i++;
+                continue;
+            }
+            // Solo contar brackets fuera de strings/templates/comentarios
+            if (char === '(')
+                counters['(']++;
+            else if (char === ')')
+                counters['(']--;
+            else if (char === '[')
+                counters['[']++;
+            else if (char === ']')
+                counters['[']--;
+            else if (char === '{')
+                counters['{']++;
+            else if (char === '}')
+                counters['{']--;
+            // Early return si algún contador se vuelve negativo
+            if (counters['('] < 0 || counters['['] < 0 || counters['{'] < 0) {
+                return false;
+            }
+            // Track prev non-whitespace char para contexto de regex
+            if (char &&
+                char !== ' ' &&
+                char !== '\t' &&
+                char !== '\n' &&
+                char !== '\r') {
+                prevNonWhitespaceChar = char;
+            }
+            i++;
+        }
+        // Verificar que todos estén balanceados
+        return (counters['('] === 0 && counters['['] === 0 && counters['{'] === 0);
+    }
+    /**
+     * Check 3: Verificar que los exports se mantengan
+     */
+    checkExports(original, processed) {
+        const originalExports = this.extractExports(original);
+        const processedExports = this.extractExports(processed);
+        // Si no hay exports en el original, no hay nada que validar
+        if (originalExports.length === 0) {
+            return true;
+        }
+        // Verificar que todos los exports originales estén presentes
+        for (const exp of originalExports) {
+            if (!processedExports.includes(exp)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Extraer exports de código JavaScript/TypeScript
+     */
+    extractExports(code) {
+        const exports = [];
+        // export default
+        if (/export\s+default\s/.test(code)) {
+            exports.push('default');
+        }
+        // export { a, b, c }
+        const namedExportsMatches = code.matchAll(/export\s*\{\s*([^}]+)\s*\}/g);
+        for (const match of namedExportsMatches) {
+            if (match[1]) {
+                const names = match[1]
+                    .split(',')
+                    .map(n => {
+                    const parts = n.trim().split(/\s+as\s+/);
+                    return parts[0]?.trim() || '';
+                })
+                    .filter(n => n);
+                exports.push(...names);
+            }
+        }
+        // export const/let/var/function/class
+        const directExportsMatches = code.matchAll(/export\s+(?:const|let|var|function|class|async\s+function)\s+(\w+)/g);
+        for (const match of directExportsMatches) {
+            if (match[1]) {
+                exports.push(match[1]);
+            }
+        }
+        // export * from
+        if (/export\s+\*\s+from/.test(code)) {
+            exports.push('*');
+        }
+        return [...new Set(exports)]; // Deduplicar
+    }
+    /**
+     * Check 4: Validación de sintaxis con oxc-parser
+     */
+    checkSyntax(code) {
+        try {
+            const parseResult = parseSync('integrity-check.js', code, {
+                sourceType: 'module',
+            });
+            return parseResult.errors.length === 0;
+        }
+        catch {
+            // Si parseSync lanza error, la sintaxis es inválida
+            return false;
+        }
+    }
+    /**
+     * Crear objeto de resultado
+     */
+    createResult(valid, checks, errors, original, processed, startTime) {
+        const duration = performance.now() - startTime;
+        return {
+            valid,
+            checks,
+            errors,
+            metrics: {
+                duration,
+                originalSize: original.length,
+                processedSize: processed.length,
+                exportCount: this.extractExports(processed).length,
+            },
+        };
+    }
+    /**
+     * Manejar resultado de validación (estadísticas, logging, errores)
+     */
+    handleValidationResult(result, context, options) {
+        // Actualizar estadísticas
+        if (result.valid) {
+            this.stats.successfulValidations++;
+        }
+        else {
+            this.stats.failedValidations++;
+        }
+        this.stats.totalDuration += result.metrics.duration;
+        this.stats.averageDuration =
+            this.stats.totalDuration / this.stats.totalValidations;
+        // Logging
+        if (options.verbose) {
+            if (result.valid) {
+                logger.info(`[IntegrityValidator] ✓ ${context} - ` +
+                    `${result.metrics.duration.toFixed(2)}ms - ` +
+                    `${result.metrics.originalSize} → ${result.metrics.processedSize} bytes`);
+            }
+            else {
+                logger.error(`[IntegrityValidator] ✗ ${context} - ` +
+                    `Failed: ${result.errors.join(', ')}`);
+            }
+        }
+        // Lanzar error si está configurado
+        if (!result.valid && options.throwOnError) {
+            throw new Error(`Integrity validation failed for ${context}: ${result.errors.join(', ')}`);
+        }
+    }
+    /**
+     * Generar clave de caché
+     */
+    getCacheKey(context, code) {
+        // Hash simple pero rápido
+        const hash = this.hashCode(code);
+        return `${context}:${hash}`;
+    }
+    /**
+     * Hash simple para cache
+     */
+    hashCode(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return hash.toString(36);
+    }
+    /**
+     * Guardar en caché con LRU eviction
+     */
+    saveToCache(key, result) {
+        // LRU eviction
+        if (this.cache.size >= this.MAX_CACHE_SIZE) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, result);
+    }
+    /**
+     * Obtener estadísticas de validación
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Limpiar caché
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Resetear estadísticas
+     */
+    resetStats() {
+        this.stats = {
+            totalValidations: 0,
+            successfulValidations: 0,
+            failedValidations: 0,
+            cacheHits: 0,
+            cacheMisses: 0,
+            totalDuration: 0,
+            averageDuration: 0,
+        };
+    }
+}
+// Export singleton instance
+export const integrityValidator = IntegrityValidator.getInstance();
+//# sourceMappingURL=integrity-validator.js.map

package/dist/compiler/minify.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { minifySync } from 'oxc-minify';
 import { logger } from '../servicios/logger.js';
+import { integrityValidator } from './integrity-validator.js';
 import { minifyTemplate } from './minifyTemplate.js';
 class MinificationCache {
     static instance;
@@ -51,6 +52,23 @@ class MinificationCache {
         const originalSize = data.length;
         try {
             const result = minifySync(filename, data, options);
+            // VALIDACIÓN DE INTEGRIDAD - Solo si flag está activo
+            if (process.env.CHECK_INTEGRITY === 'true') {
+                const validation = integrityValidator.validate(data, result.code, `minify:${filename}`, {
+                    skipSyntaxCheck: false,
+                    verbose: process.env.VERBOSE === 'true',
+                    throwOnError: true, // Detener build si falla
+                });
+                if (!validation.valid) {
+                    // El validator ya lanzó el error si throwOnError=true
+                    // Pero por si acaso, retornamos el código original
+                    logger.error(`❌ Validación de integridad fallida para ${filename}`, validation.errors.join(', '));
+                    throw new Error(`Integrity check failed for ${filename}: ${validation.errors.join(', ')}`);
+                }
+                if (process.env.VERBOSE === 'true') {
+                    logger.info(`✅ Validación de integridad OK para ${filename} (${validation.metrics.duration.toFixed(2)}ms)`);
+                }
+            }
             // Si el código de entrada no estaba vacío pero el resultado sí,
             // retornar código original sin minificar con advertencia
             if (data.trim() && !result.code.trim()) {
@@ -233,7 +251,7 @@ export const minifyJS = async (data, filename, isProd = true) => {
                 normal: true,
                 jsdoc: true,
                 annotation: true,
-                legal: true
+                legal: true,
             },
             sourcemap: !isProd,
         };

package/dist/compiler/minifyTemplate.js

@@ -1,5 +1,6 @@
 import { minifyHTMLLiterals } from 'minify-html-literals';
 import { logger } from '../servicios/logger.js';
+import { integrityValidator } from './integrity-validator.js';
 const defaultMinifyOptions = {
     // Opciones esenciales para componentes Vue
     caseSensitive: true, // Preserva mayúsculas/minúsculas en nombres de componentes
@@ -219,6 +220,21 @@ const minifyTemplate = (data, fileName) => {
         // Esto convierte __VERSA_TEMP__` de vuelta a ` para que el código
         // final no contenga los marcadores temporales
         const finalCode = removeTemporaryTags(minifiedCode);
+        // VALIDACIÓN DE INTEGRIDAD - Solo si flag está activo
+        if (process.env.CHECK_INTEGRITY === 'true') {
+            const validation = integrityValidator.validate(data, finalCode, `minifyTemplate:${fileName}`, {
+                skipSyntaxCheck: true, // No validar sintaxis (puede no ser JS puro)
+                verbose: process.env.VERBOSE === 'true',
+                throwOnError: true, // Detener build si falla
+            });
+            if (!validation.valid) {
+                logger.error(`❌ Validación de integridad fallida para template ${fileName}`, validation.errors.join(', '));
+                throw new Error(`Template integrity check failed for ${fileName}: ${validation.errors.join(', ')}`);
+            }
+            if (process.env.VERBOSE === 'true') {
+                logger.info(`✅ Validación de template OK para ${fileName} (${validation.metrics.duration.toFixed(2)}ms)`);
+            }
+        }
         return { code: finalCode, error: null };
     }
     catch (error) {

package/dist/compiler/transforms.js

@@ -3,9 +3,24 @@ import { env } from 'node:process';
 import { logger } from '../servicios/logger.js';
 import { EXCLUDED_MODULES } from '../utils/excluded-modules.js';
 import { getModuleSubPath } from '../utils/module-resolver.js';
+import { integrityValidator } from './integrity-validator.js';
 import { analyzeAndFormatMultipleErrors } from './error-reporter.js';
 import { getOptimizedAliasPath, getOptimizedModulePath, } from './module-resolution-optimizer.js';
 import { parser } from './parser.js';
+// ✨ OPTIMIZACIÓN CRÍTICA: Cache de PATH_ALIAS parseado
+let cachedPathAlias = null;
+let lastPathAliasString = null;
+function getParsedPathAlias() {
+    if (!env.PATH_ALIAS)
+        return null;
+    // Solo parsear si el string cambió
+    if (cachedPathAlias && lastPathAliasString === env.PATH_ALIAS) {
+        return cachedPathAlias;
+    }
+    cachedPathAlias = JSON.parse(env.PATH_ALIAS);
+    lastPathAliasString = env.PATH_ALIAS;
+    return cachedPathAlias;
+}
 // Módulos built-in de Node.js que no deben ser resueltos
 const NODE_BUILTIN_MODULES = new Set([
     'fs',
@@ -94,7 +109,7 @@ export async function replaceAliasImportStatic(file, code) {
     if (!env.PATH_ALIAS || !env.PATH_DIST) {
         return code;
     }
-    const pathAlias = JSON.parse(env.PATH_ALIAS);
+    const pathAlias = getParsedPathAlias();
     let resultCode = code;
     // Usar regex para transformar imports estáticos
     const importRegex = /import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)(?:\s*,\s*(?:\{[^}]*\}|\*\s+as\s+\w+|\w+))*\s+from\s+)?['"`]([^'"`]+)['"`]/g;
@@ -206,7 +221,7 @@ export async function replaceAliasImportDynamic(code, _imports, file) {
     if (!env.PATH_ALIAS || !env.PATH_DIST) {
         return code;
     }
-    const pathAlias = JSON.parse(env.PATH_ALIAS);
+    const pathAlias = getParsedPathAlias();
     const pathDist = env.PATH_DIST;
     let resultCode = code;
     // Regex para imports dinámicos normales con string (solo comillas simples y dobles)
@@ -391,7 +406,7 @@ async function replaceAliasInStrings(code) {
     if (!env.PATH_ALIAS || !env.PATH_DIST) {
         return code;
     }
-    const pathAlias = JSON.parse(env.PATH_ALIAS);
+    const pathAlias = getParsedPathAlias();
     const pathDist = env.PATH_DIST;
     let resultCode = code; // Regex para encontrar strings que contengan posibles alias
     // Busca strings entre comillas simples, dobles o backticks que contengan alias
@@ -518,6 +533,7 @@ const removeCodeTagImport = async (data) => {
     return data;
 };
 export async function estandarizaCode(code, file) {
+    const originalCode = code; // Guardar código original para validación
     try {
         const ast = await parser(file, code);
         if (ast && ast.errors && ast.errors.length > 0) {
@@ -542,6 +558,21 @@ export async function estandarizaCode(code, file) {
         if (env.isPROD === 'true') {
             code = await removePreserverComent(code);
         }
+        // VALIDACIÓN DE INTEGRIDAD - Solo si flag está activo
+        if (env.CHECK_INTEGRITY === 'true') {
+            const validation = integrityValidator.validate(originalCode, code, `transforms:${path.basename(file)}`, {
+                skipSyntaxCheck: false, // SÍ validar sintaxis en transformaciones
+                verbose: env.VERBOSE === 'true',
+                throwOnError: true,
+            });
+            if (!validation.valid) {
+                logger.error(`❌ Validación de integridad fallida en transformaciones para ${path.basename(file)}`, validation.errors.join(', '));
+                throw new Error(`Transform integrity check failed for ${path.basename(file)}: ${validation.errors.join(', ')}`);
+            }
+            if (env.VERBOSE === 'true') {
+                logger.info(`✅ Validación de transformaciones OK para ${path.basename(file)} (${validation.metrics.duration.toFixed(2)}ms)`);
+            }
+        }
         return { code, error: null };
     }
     catch (error) {