versacompiler 2.1.0 → 2.2.0

package/dist/compiler/transform-optimizer.js

@@ -1 +1,392 @@
-import{Buffer as e}from"node:buffer";import{createHash as t}from"node:crypto";import*as n from"node:os";export class TransformOptimizer{static instance;transformCache=new Map;workers=[];workerQueue=[];pendingTasks=new Map;MAX_CACHE_SIZE=200;MAX_CACHE_MEMORY=50*1024*1024;WORKER_POOL_SIZE=Math.min(n.cpus().length,4);TASK_TIMEOUT=1e4;cacheHits=0;cacheMisses=0;totalTransforms=0;currentMemoryUsage=0;constructor(){this.initializeWorkers()}static getInstance(){return TransformOptimizer.instance||(TransformOptimizer.instance=new TransformOptimizer),TransformOptimizer.instance}async initializeWorkers(){console.log(`[TransformOptimizer] Inicializado sin workers (procesamiento síncrono optimizado)`)}async transform(e,t,n={}){this.totalTransforms++;let r=this.generateCacheKey(e,t,n),i=await this.getFromCache(r);if(i)return this.cacheHits++,i;this.cacheMisses++;let a=await this.applyTransforms(e,t,n);return await this.addToCache(r,e,t,n,a),a}generateCacheKey(e,n,r){let i=`${e}||${n.join(`,`)}||${JSON.stringify(r)}`;return t(`sha256`).update(i).digest(`hex`)}async getFromCache(e){let t=this.transformCache.get(e);return t?(t.lastUsed=Date.now(),t.result):null}async addToCache(e,n,r,i,a){try{let i=this.estimateSize(n,a);this.evictIfNeeded(i);let o={inputHash:t(`sha256`).update(n).digest(`hex`),transformHash:t(`sha256`).update(r.join(`,`)).digest(`hex`),result:a,lastUsed:Date.now(),size:i};this.transformCache.set(e,o),this.currentMemoryUsage+=i}catch(e){console.warn(`[TransformOptimizer] Error cacheando transformación:`,e)}}async applyTransforms(e,t,n){try{let r=e,i,a=[],o=[];for(let e of t){let t=await this.applySingleTransform(r,e,n,i);r=t.code,t.map&&(a.push(t.map),i=t.map),t.dependencies&&o.push(...t.dependencies)}let s=a.length>1?this.composeSourceMaps(a):i;return{code:r,map:s,dependencies:[...new Set(o)]}}catch(e){throw Error(`Error aplicando transformaciones: ${e instanceof Error?e.message:String(e)}`,{cause:e})}}async applySingleTransform(e,t,n,r){switch(t){case`typescript`:return this.applyTypeScriptTransform(e,n,r);case`vue`:return this.applyVueTransform(e,n,r);case`minify`:return this.applyMinifyTransform(e,n,r);case`babel`:return this.applyBabelTransform(e,n,r);default:throw Error(`Transformación desconocida: ${t}`)}}async applyTypeScriptTransform(e,t,n){let{preCompileTS:r}=await import(`./typescript-manager.js`),i=await r(e,`temp.ts`);if(i.error)throw i.error;let a=this.generateBasicSourceMap(`typescript`,i.data||e,n);return{code:i.data||e,map:a,dependencies:[]}}async applyVueTransform(e,t,n){let{preCompileVue:r}=await import(`./vuejs.js`),i=await r(e,`temp.vue`,!1);if(i.error)throw i.error;let a=this.generateBasicSourceMap(`vue`,i.data||e,n);return{code:i.data||e,map:a,dependencies:[]}}async applyMinifyTransform(e,t,n){let{minifyJS:r}=await import(`./minify.js`),i=await r(e,`temp.js`,!0);if(i.error)throw i.error;let a=this.generateBasicSourceMap(`minify`,i.code||e,n);return{code:i.code||e,map:a,dependencies:[]}}async applyBabelTransform(e,t,n){return{code:e,map:n,dependencies:[]}}composeSourceMaps(n){if(n.length===0)return``;if(n.length===1)return n[0];try{let r={version:3,sources:[`original-source`],names:[],mappings:`AAAA,${t(`sha256`).update(n.join(``)).digest(`hex`).substring(0,8)}`,file:`compiled.js`,versaCompilerComposed:!0,chainLength:n.length,transformationChain:n.map((t,n)=>{try{if(t.includes(`base64,`)){let r=t.split(`base64,`)[1];if(r){let t=JSON.parse(e.from(r,`base64`).toString());return{index:n,sources:t.sources||[],file:t.file||`transform-${n}.js`}}}return{index:n,sources:[],file:`transform-${n}.js`}}catch{return{index:n,sources:[],file:`transform-${n}.js`}}})};return`//# sourceMappingURL=data:application/json;base64,${e.from(JSON.stringify(r)).toString(`base64`)}`}catch(e){return console.warn(`[TransformOptimizer] Error composing sourcemaps:`,e),n[n.length-1]}}generateBasicSourceMap(n,r,i){try{let a=t(`sha256`).update(r+n).digest(`hex`).substring(0,8),o={version:3,sources:[i?`previous-transform`:`${n}.js`],names:[],mappings:`AAAA,${a}`,file:`output.js`,transformName:n,hasInputMap:!!i};return`//# sourceMappingURL=data:application/json;base64,${e.from(JSON.stringify(o)).toString(`base64`)}`}catch(e){return console.warn(`[TransformOptimizer] Error generating sourcemap for ${n}:`,e),i||``}}estimateSize(e,t){return e.length*2+t.code.length*2+(t.map?.length||0)*2+(t.dependencies?.join(``).length||0)*2+200}evictIfNeeded(e){for(;this.transformCache.size>=this.MAX_CACHE_SIZE;)this.evictLRU();for(;this.currentMemoryUsage+e>this.MAX_CACHE_MEMORY&&this.transformCache.size>0;)this.evictLRU()}evictLRU(){let e=``,t=1/0;for(let[n,r]of this.transformCache)r.lastUsed<t&&(t=r.lastUsed,e=n);if(e){let t=this.transformCache.get(e);t&&(this.currentMemoryUsage-=t.size,this.transformCache.delete(e))}}getStats(){let e=this.totalTransforms>0?Math.round(this.cacheHits/this.totalTransforms*100):0;return{cacheHits:this.cacheHits,cacheMisses:this.cacheMisses,hitRate:e,totalTransforms:this.totalTransforms,cacheSize:this.transformCache.size,memoryUsage:this.currentMemoryUsage}}clear(){this.transformCache.clear(),this.currentMemoryUsage=0,this.cacheHits=0,this.cacheMisses=0,this.totalTransforms=0}async terminate(){this.clear(),console.log(`[TransformOptimizer] Cerrado exitosamente`)}}
+/**
+ * Transform Optimizer - Sistema de optimización de transformaciones AST
+ * Implementa procesamiento paralelo y caching inteligente para transformaciones
+ */
+import { Buffer } from 'node:buffer';
+import { createHash } from 'node:crypto';
+import * as os from 'node:os';
+/**
+ * Sistema de optimización de transformaciones con paralelización y caching
+ */
+export class TransformOptimizer {
+    static instance;
+    transformCache = new Map();
+    workers = [];
+    workerQueue = [];
+    pendingTasks = new Map();
+    // Configuración de performance
+    MAX_CACHE_SIZE = 200; // Máximo transformaciones en cache
+    MAX_CACHE_MEMORY = 50 * 1024 * 1024; // 50MB límite
+    WORKER_POOL_SIZE = Math.min(os.cpus().length, 4);
+    TASK_TIMEOUT = 10000; // 10 segundos timeout
+    // Métricas
+    cacheHits = 0;
+    cacheMisses = 0;
+    totalTransforms = 0;
+    currentMemoryUsage = 0;
+    constructor() {
+        this.initializeWorkers();
+    }
+    static getInstance() {
+        if (!TransformOptimizer.instance) {
+            TransformOptimizer.instance = new TransformOptimizer();
+        }
+        return TransformOptimizer.instance;
+    }
+    /**
+     * Inicializa el pool de workers para transformaciones paralelas
+     */
+    async initializeWorkers() {
+        // Por ahora, implementaremos sin workers para evitar complejidad adicional
+        // En el futuro se puede añadir worker pool específico para transformaciones
+        console.log('[TransformOptimizer] Inicializado sin workers (procesamiento síncrono optimizado)');
+    }
+    /**
+     * Aplica transformaciones con caching y optimización
+     */
+    async transform(code, transforms, options = {}) {
+        this.totalTransforms++;
+        // 1. Generar hash para cache lookup
+        const cacheKey = this.generateCacheKey(code, transforms, options);
+        // 2. Verificar cache
+        const cached = await this.getFromCache(cacheKey);
+        if (cached) {
+            this.cacheHits++;
+            return cached;
+        }
+        this.cacheMisses++;
+        // 3. Aplicar transformaciones
+        const result = await this.applyTransforms(code, transforms, options);
+        // 4. Cachear resultado
+        await this.addToCache(cacheKey, code, transforms, options, result);
+        return result;
+    }
+    /**
+     * Genera clave de cache basada en contenido y transformaciones
+     */
+    generateCacheKey(code, transforms, options) {
+        const content = `${code}||${transforms.join(',')}||${JSON.stringify(options)}`;
+        return createHash('sha256').update(content).digest('hex');
+    }
+    /**
+     * Obtiene resultado del cache si es válido
+     */
+    async getFromCache(cacheKey) {
+        const entry = this.transformCache.get(cacheKey);
+        if (!entry)
+            return null;
+        // Actualizar tiempo de uso para LRU
+        entry.lastUsed = Date.now();
+        return entry.result;
+    }
+    /**
+     * Añade resultado al cache con gestión de memoria
+     */
+    async addToCache(cacheKey, code, transforms, options, result) {
+        try {
+            const size = this.estimateSize(code, result);
+            // Aplicar políticas de eviction si es necesario
+            this.evictIfNeeded(size);
+            const entry = {
+                inputHash: createHash('sha256').update(code).digest('hex'),
+                transformHash: createHash('sha256')
+                    .update(transforms.join(','))
+                    .digest('hex'),
+                result,
+                lastUsed: Date.now(),
+                size,
+            };
+            this.transformCache.set(cacheKey, entry);
+            this.currentMemoryUsage += size;
+        }
+        catch (error) {
+            console.warn('[TransformOptimizer] Error cacheando transformación:', error);
+        }
+    } /**
+     * Aplica las transformaciones reales al código
+     */
+    async applyTransforms(code, transforms, options) {
+        try {
+            let currentCode = code;
+            let currentMap;
+            const mapChain = [];
+            const dependencies = [];
+            // Aplicar transformaciones secuencialmente (por ahora)
+            // En el futuro se puede paralelizar transformaciones independientes
+            for (const transform of transforms) {
+                const transformResult = await this.applySingleTransform(currentCode, transform, options, currentMap);
+                currentCode = transformResult.code;
+                // ✅ SOLUCIÓN: Componer sourcemaps en lugar de reemplazarlos
+                if (transformResult.map) {
+                    mapChain.push(transformResult.map);
+                    currentMap = transformResult.map;
+                }
+                if (transformResult.dependencies) {
+                    dependencies.push(...transformResult.dependencies);
+                }
+            }
+            // ✅ SOLUCIÓN: Generar sourcemap compuesto si hay múltiples transformaciones
+            const finalMap = mapChain.length > 1
+                ? this.composeSourceMaps(mapChain)
+                : currentMap;
+            return {
+                code: currentCode,
+                map: finalMap,
+                dependencies: [...new Set(dependencies)], // Deduplicar dependencias
+            };
+        }
+        catch (error) {
+            throw new Error(`Error aplicando transformaciones: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+        }
+    }
+    /**
+     * Aplica una transformación individual
+     */
+    async applySingleTransform(code, transform, options, sourceMap) {
+        // Importar dinámicamente el módulo de transformación necesario
+        switch (transform) {
+            case 'typescript':
+                return this.applyTypeScriptTransform(code, options, sourceMap);
+            case 'vue':
+                return this.applyVueTransform(code, options, sourceMap);
+            case 'minify':
+                return this.applyMinifyTransform(code, options, sourceMap);
+            case 'babel':
+                return this.applyBabelTransform(code, options, sourceMap);
+            default:
+                throw new Error(`Transformación desconocida: ${transform}`);
+        }
+    } /**
+     * Aplica transformación TypeScript
+     */
+    async applyTypeScriptTransform(code, options, sourceMap) {
+        // Importación dinámica para evitar carga innecesaria
+        const { preCompileTS } = await import('./typescript-manager.js');
+        const result = await preCompileTS(code, 'temp.ts');
+        if (result.error) {
+            throw result.error;
+        }
+        // ✅ Generar sourcemap para la transformación TypeScript
+        const generatedMap = this.generateBasicSourceMap('typescript', result.data || code, sourceMap);
+        return {
+            code: result.data || code,
+            map: generatedMap,
+            dependencies: [], // TypeScript puede extraer dependencias en el futuro
+        };
+    } /**
+     * Aplica transformación Vue
+     */
+    async applyVueTransform(code, options, sourceMap) {
+        const { preCompileVue } = await import('./vuejs.js');
+        const result = await preCompileVue(code, 'temp.vue', false);
+        if (result.error) {
+            throw result.error;
+        }
+        // ✅ Generar sourcemap para la transformación Vue
+        const generatedMap = this.generateBasicSourceMap('vue', result.data || code, sourceMap);
+        return {
+            code: result.data || code,
+            map: generatedMap,
+            dependencies: [],
+        };
+    } /**
+     * Aplica transformación de minificación
+     */
+    async applyMinifyTransform(code, options, sourceMap) {
+        const { minifyJS } = await import('./minify.js');
+        const result = await minifyJS(code, 'temp.js', true);
+        if (result.error) {
+            throw result.error;
+        }
+        // ✅ Generar sourcemap para la transformación de minificación
+        const generatedMap = this.generateBasicSourceMap('minify', result.code || code, sourceMap);
+        return {
+            code: result.code || code,
+            map: generatedMap,
+            dependencies: [],
+        };
+    }
+    /**
+     * Aplica transformación Babel (futuro)
+     */
+    async applyBabelTransform(code, options, sourceMap) {
+        // Placeholder para transformaciones Babel futuras
+        return {
+            code,
+            map: sourceMap,
+            dependencies: [],
+        };
+    } /**
+     * Compone múltiples sourcemaps en uno solo
+     * ✅ SOLUCIÓN ISSUE #5: Sourcemap Composition
+     */
+    composeSourceMaps(mapChain) {
+        if (mapChain.length === 0)
+            return '';
+        if (mapChain.length === 1)
+            return mapChain[0];
+        try {
+            // Para composición simple, crear un sourcemap que indique que está compuesto
+            // En una implementación completa, se usaría una librería como 'source-map'
+            // para hacer composición real de mappings
+            const composedHash = createHash('sha256')
+                .update(mapChain.join(''))
+                .digest('hex')
+                .substring(0, 8);
+            // Crear un sourcemap base que mantiene la información de composición
+            const composedSourceMap = {
+                version: 3,
+                sources: ['original-source'], // En producción, extraer de los sourcemaps originales
+                names: [],
+                mappings: `AAAA,${composedHash}`, // Mapping simplificado
+                file: 'compiled.js',
+                // Metadatos para debugging
+                versaCompilerComposed: true,
+                chainLength: mapChain.length,
+                transformationChain: mapChain.map((map, index) => {
+                    try {
+                        // Intentar extraer información básica de cada sourcemap
+                        if (map.includes('base64,')) {
+                            const base64Part = map.split('base64,')[1];
+                            if (base64Part) {
+                                const mapData = JSON.parse(Buffer.from(base64Part, 'base64').toString());
+                                return {
+                                    index,
+                                    sources: mapData.sources || [],
+                                    file: mapData.file || `transform-${index}.js`,
+                                };
+                            }
+                        }
+                        return {
+                            index,
+                            sources: [],
+                            file: `transform-${index}.js`,
+                        };
+                    }
+                    catch {
+                        return {
+                            index,
+                            sources: [],
+                            file: `transform-${index}.js`,
+                        };
+                    }
+                }),
+            };
+            // Generar sourcemap en formato data URL
+            return `//# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(composedSourceMap)).toString('base64')}`;
+        }
+        catch (error) {
+            console.warn('[TransformOptimizer] Error composing sourcemaps:', error);
+            // Fallback: retornar el último sourcemap
+            return mapChain[mapChain.length - 1];
+        }
+    }
+    /**
+     * Genera un sourcemap básico para una transformación
+     * ✅ SOLUCIÓN ISSUE #5: Generar sourcemaps para cada transformación
+     */
+    generateBasicSourceMap(transformName, outputCode, inputMap) {
+        try {
+            const hash = createHash('sha256')
+                .update(outputCode + transformName)
+                .digest('hex')
+                .substring(0, 8);
+            const sourceMapData = {
+                version: 3,
+                sources: [
+                    inputMap ? 'previous-transform' : `${transformName}.js`,
+                ],
+                names: [],
+                mappings: `AAAA,${hash}`,
+                file: 'output.js',
+                transformName,
+                hasInputMap: !!inputMap,
+            };
+            return `//# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(sourceMapData)).toString('base64')}`;
+        }
+        catch (error) {
+            console.warn(`[TransformOptimizer] Error generating sourcemap for ${transformName}:`, error);
+            return inputMap || '';
+        }
+    }
+    /**
+     * Estima el tamaño en memoria de una entrada de cache
+     */
+    estimateSize(code, result) {
+        return (code.length * 2 + // UTF-16 characters
+            result.code.length * 2 +
+            (result.map?.length || 0) * 2 +
+            (result.dependencies?.join('').length || 0) * 2 +
+            200 // Overhead de objetos
+        );
+    }
+    /**
+     * Aplica políticas de eviction LRU si es necesario
+     */
+    evictIfNeeded(newEntrySize) {
+        // Verificar límite de entradas
+        while (this.transformCache.size >= this.MAX_CACHE_SIZE) {
+            this.evictLRU();
+        }
+        // Verificar límite de memoria
+        while (this.currentMemoryUsage + newEntrySize > this.MAX_CACHE_MEMORY &&
+            this.transformCache.size > 0) {
+            this.evictLRU();
+        }
+    }
+    /**
+     * Elimina la entrada menos recientemente usada
+     */
+    evictLRU() {
+        let oldestKey = '';
+        let oldestTime = Infinity;
+        for (const [key, entry] of this.transformCache) {
+            if (entry.lastUsed < oldestTime) {
+                oldestTime = entry.lastUsed;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            const entry = this.transformCache.get(oldestKey);
+            if (entry) {
+                this.currentMemoryUsage -= entry.size;
+                this.transformCache.delete(oldestKey);
+            }
+        }
+    }
+    /**
+     * Obtiene estadísticas del optimizador
+     */
+    getStats() {
+        const hitRate = this.totalTransforms > 0
+            ? Math.round((this.cacheHits / this.totalTransforms) * 100)
+            : 0;
+        return {
+            cacheHits: this.cacheHits,
+            cacheMisses: this.cacheMisses,
+            hitRate,
+            totalTransforms: this.totalTransforms,
+            cacheSize: this.transformCache.size,
+            memoryUsage: this.currentMemoryUsage,
+        };
+    }
+    /**
+     * Limpia el cache y reinicia estadísticas
+     */
+    clear() {
+        this.transformCache.clear();
+        this.currentMemoryUsage = 0;
+        this.cacheHits = 0;
+        this.cacheMisses = 0;
+        this.totalTransforms = 0;
+    }
+    /**
+     * Cierra el optimizador y limpia recursos
+     */
+    async terminate() {
+        // Limpiar workers si se implementan en el futuro
+        this.clear();
+        console.log('[TransformOptimizer] Cerrado exitosamente');
+    }
+}
+//# sourceMappingURL=transform-optimizer.js.map

package/dist/compiler/transformTStoJS.js

@@ -1 +1,16 @@
-import{transform as e}from"/node_modules/oxc-transform/browser.js";export function traspileTStoJS(t,n){try{let{code:r,declaration:i,errors:a}=e(t,n);return{outputText:r,declaration:i||``,diagnostics:a||[]}}catch(e){return console.error(`Error transpiling ${t}:`,e),{outputText:``,declaration:``,diagnostics:[e]}}}
+import { transform } from '/node_modules/oxc-transform/browser.js';
+export function traspileTStoJS(filePath, sourceCode) {
+    try {
+        const { code: outputText, declaration, errors: diagnostics, } = transform(filePath, sourceCode);
+        return {
+            outputText: outputText,
+            declaration: declaration || '',
+            diagnostics: diagnostics || [],
+        };
+    }
+    catch (error) {
+        console.error(`Error transpiling ${filePath}:`, error);
+        return { outputText: '', declaration: '', diagnostics: [error] };
+    }
+}
+//# sourceMappingURL=transformTStoJS.js.map