versacompiler 2.0.4 → 2.0.5

package/dist/compiler/typescript-sync-validator.js

@@ -6,6 +6,42 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as process from 'node:process';
 import * as typescript from 'typescript';
+/**
+ * Genera declaraciones básicas de tipos para Vue como fallback
+ */
+const generateBasicVueTypes = () => {
+    return `// Declaraciones básicas de tipos Vue para validación
+declare global {
+    function ref<T>(value: T): { value: T };
+    function reactive<T extends object>(target: T): T;
+    function computed<T>(getter: () => T): { value: T };
+    function defineComponent<T>(options: T): T;
+    function defineProps<T = {}>(): T;
+    function defineEmits<T = {}>(): T;
+    function defineExpose<T = {}>(exposed: T): void;
+    function onMounted(fn: () => void): void;
+    function onUnmounted(fn: () => void): void;
+    function onBeforeMount(fn: () => void): void;
+    function onBeforeUnmount(fn: () => void): void;
+    function onUpdated(fn: () => void): void;
+    function onBeforeUpdate(fn: () => void): void;
+    function provide<T>(key: string | symbol, value: T): void;
+    function inject<T>(key: string | symbol, defaultValue?: T): T | undefined;
+    function useSlots(): { [key: string]: (...args: any[]) => any };
+    function useAttrs(): { [key: string]: any };
+    function useModel<T>(modelName?: string): { value: T };
+    function watch<T>(source: () => T, callback: (newValue: T, oldValue: T) => void): void;
+    function watchEffect(effect: () => void): void;
+    function nextTick(callback?: () => void): Promise<void>;
+    function getCurrentInstance(): any;
+    function mergeModels<T>(models: T): T;
+}
+declare module '*.vue' {
+    const component: any;
+    export default component;
+}
+export {};`;
+};
 /**
  * Language Service Host para validación de tipos eficiente
  */
@@ -13,7 +49,11 @@ class TypeScriptLanguageServiceHost {
     files = new Map();
     compilerOptions;
     constructor(compilerOptions) {
-        this.compilerOptions = compilerOptions;
+        this.compilerOptions = {
+            ...compilerOptions,
+            // Asegurar que las librerías DOM estén incluidas para archivos Vue
+            lib: compilerOptions.lib || ['ES2020', 'DOM', 'DOM.Iterable'],
+        };
     }
     addFile(fileName, content) {
         const existing = this.files.get(fileName);
@@ -84,58 +124,52 @@ class TypeScriptLanguageServiceHost {
  * @returns Resultado de la validación de tipos
  */
 export const validateTypesWithLanguageService = (fileName, content, compilerOptions) => {
-    let actualFileName = fileName; // Declarar aquí para acceso en catch
     try {
-        const scriptContent = content;
         // Si el script está vacío o es solo espacios en blanco, no validar
-        if (!scriptContent.trim()) {
+        if (!content.trim()) {
             return { diagnostics: [], hasErrors: false };
-        }
-        // Crear Language Service Host
+        } // Crear Language Service Host
         const host = new TypeScriptLanguageServiceHost(compilerOptions);
         // Para archivos Vue, crear un archivo virtual .ts
+        let actualFileName = fileName;
         if (fileName.endsWith('.vue')) {
-            // Usar ruta absoluta para el archivo virtual
-            const absolutePath = path.isAbsolute(fileName)
-                ? fileName
-                : path.resolve(fileName);
-            // Crear un nombre de archivo virtual único que no colisione
-            const virtualFileName = absolutePath.replace('.vue', '.vue.ts');
-            host.addFile(virtualFileName, scriptContent);
-            actualFileName = virtualFileName;
-        }
-        else {
-            // Para archivos virtuales, usar el nombre tal como viene (como en el worker)
-            host.addFile(fileName, scriptContent);
-            actualFileName = fileName;
+            // Crear un nombre de archivo virtual con extensión .ts
+            actualFileName = fileName.replace('.vue', '.vue.ts');
         }
-        // Agregar declaraciones básicas de tipos para Vue si es necesario
+        // Agregar el archivo al host con el nombre correcto
+        host.addFile(actualFileName, content);
+        // Agregar declaraciones de tipos para Vue si es necesario
         if (fileName.endsWith('.vue')) {
-            // Usar el directorio del archivo actual para las declaraciones
-            const projectDir = path.dirname(actualFileName);
-            const vueTypesPath = path.join(projectDir, 'vue-types.d.ts');
-            const vueTypesDeclaration = `// Declaraciones de tipos Vue para validación
-                declare global {
-                    function ref<T>(value: T): { value: T };
-                    function reactive<T extends object>(target: T): T;
-                    function computed<T>(getter: () => T): { value: T };
-                    function defineComponent<T>(options: T): T;
-                    function defineProps<T = {}>(): T;
-                    function defineEmits<T = {}>(): T;
-                    function onMounted(fn: () => void): void;
-                    function onUnmounted(fn: () => void): void;
-                    function watch<T>(source: () => T, callback: (newValue: T, oldValue: T) => void): void;
-                }
-                export {};            `;
-            host.addFile(vueTypesPath, vueTypesDeclaration);
+            // Cargar declaraciones de tipos Vue desde archivo shims
+            const projectRoot = process.cwd();
+            const vueShimsPath = path.join(projectRoot, 'src/types/vue-shims.d.ts');
+            try {
+                if (fs.existsSync(vueShimsPath)) {
+                    const vueShimsContent = fs.readFileSync(vueShimsPath, 'utf-8');
+                    host.addFile(vueShimsPath, vueShimsContent);
+                }
+                else {
+                    // Fallback a declaraciones básicas si no se encuentra el archivo shims
+                    const basicVueTypes = generateBasicVueTypes();
+                    const fallbackTypesPath = path.join(path.dirname(fileName), 'vue-fallback.d.ts');
+                    host.addFile(fallbackTypesPath, basicVueTypes);
+                }
+            }
+            catch (error) {
+                // Si hay error cargando los tipos, usar fallback básico
+                console.warn('Error al cargar tipos Vue:', error);
+                const basicVueTypes = generateBasicVueTypes();
+                const fallbackTypesPath = path.join(path.dirname(fileName), 'vue-fallback.d.ts');
+                host.addFile(fallbackTypesPath, basicVueTypes);
+            }
         } // Crear Language Service
         const languageService = typescript.createLanguageService(host);
         try {
             // Verificar que el archivo existe en el host antes de solicitar diagnósticos
             if (!host.fileExists(actualFileName)) {
+                console.log('File does not exist in host, returning empty result');
                 return { diagnostics: [], hasErrors: false };
-            }
-            // Obtener diagnósticos de tipos con manejo de errores
+            } // Obtener diagnósticos de tipos con manejo de errores
             let syntacticDiagnostics = [];
             let semanticDiagnostics = [];
             try {
@@ -156,39 +190,73 @@ export const validateTypesWithLanguageService = (fileName, content, compilerOpti
             const allDiagnostics = [
                 ...syntacticDiagnostics,
                 ...semanticDiagnostics,
-            ]; // Filtrar diagnósticos relevantes
+            ];
+            // Filtrar diagnósticos relevantes con mejor manejo para Vue
             const filteredDiagnostics = allDiagnostics.filter((diag) => {
                 const messageText = typescript.flattenDiagnosticMessageText(diag.messageText, '\n');
-                // Solo errores de categoría Error
+                // Solo errores de categoría Error (no warnings)
                 if (diag.category !== typescript.DiagnosticCategory.Error) {
                     return false;
+                } // Errores de infraestructura que siempre se filtran
+                const infrastructureErrors = [
+                    'Cannot find module',
+                    'Could not find source file',
+                    "has no exported member 'mergeModels'",
+                    'Unable to resolve signature of method decorator',
+                    'The runtime will invoke the decorator with',
+                    'Module resolution kind is not specified',
+                    'Cannot resolve module',
+                    "Cannot find name 'console'", // Error común al usar console en entorno sin DOM
+                    'Do you need to change your target library', // Sugerencia de librerías
+                ];
+                for (const errorPattern of infrastructureErrors) {
+                    if (messageText.includes(errorPattern)) {
+                        return false;
+                    }
+                } // Códigos de error específicos que se filtran
+                const filteredErrorCodes = [
+                    1241, // decorator signature mismatch
+                    2307, // Cannot find module (redundant but explicit)
+                    2584, // Cannot find name (ej: console sin DOM lib)
+                    6133, // unused variables (warnings, not errors in this context)
+                ];
+                if (filteredErrorCodes.includes(diag.code)) {
+                    return false;
+                }
+                // Para archivos Vue, filtrar solo errores específicos de infraestructura
+                if (fileName.endsWith('.vue')) {
+                    // Parámetros implícitos generados automáticamente por Vue
+                    const vueImplicitParams = [
+                        '$props',
+                        '$setup',
+                        '$data',
+                        '$options',
+                        '$event',
+                        '_ctx',
+                        '_cache',
+                        '__expose',
+                        '__emit',
+                        '__slots',
+                        '__props',
+                        '__defaults',
+                    ];
+                    // Solo filtrar errores de 'any' implícito para parámetros de infraestructura de Vue
+                    if (messageText.includes("implicitly has an 'any' type")) {
+                        const hasVueImplicitParam = vueImplicitParams.some(param => messageText.includes(`'${param}'`) ||
+                            messageText.includes(`"${param}"`));
+                        if (hasVueImplicitParam) {
+                            return false;
+                        }
+                    }
+                    // Filtrar errores específicos de setup function
+                    if (messageText.includes('Parameter') &&
+                        messageText.includes('implicitly has an') &&
+                        vueImplicitParams.some(param => messageText.includes(param))) {
+                        return false;
+                    }
                 }
-                // Ignorar SOLO errores específicos de infraestructura Vue y rutas de módulos
-                return (!messageText.includes('Cannot find module') &&
-                    !messageText.includes('Could not find source file') &&
-                    !messageText.includes("Parameter '$props' implicitly has an 'any' type") &&
-                    !messageText.includes("Parameter '$setup' implicitly has an 'any' type") &&
-                    !messageText.includes("Parameter '$data' implicitly has an 'any' type") &&
-                    !messageText.includes("Parameter '$options' implicitly has an 'any' type") &&
-                    !messageText.includes("Parameter '$event' implicitly has an 'any' type") &&
-                    !messageText.includes("Parameter '_ctx' implicitly has an 'any' type") &&
-                    !messageText.includes("Parameter '_cache' implicitly has an 'any' type") &&
-                    // Ignorar errores específicos de decorators cuando están mal configurados
-                    !messageText.includes('Unable to resolve signature of method decorator when called as an expression') &&
-                    !messageText.includes('The runtime will invoke the decorator with') &&
-                    // Ignorar errores TS7031 (binding element implicitly has any type)
-                    diag.code !== 7031 &&
-                    // Ignorar errores TS7006 (parameter implicitly has any type)
-                    diag.code !== 7006 &&
-                    // Ignorar errores TS1241 (decorator signature mismatch) durante desarrollo
-                    diag.code !== 1241 &&
-                    // Permitir errores de "Cannot find name" ya que son errores de código real
-                    // Solo filtrar parámetros implícitos de Vue generados automáticamente
-                    !(messageText.includes("implicitly has an 'any' type") &&
-                        (messageText.includes('_ctx') ||
-                            messageText.includes('_cache') ||
-                            messageText.includes('$props') ||
-                            messageText.includes('$setup'))));
+                // Mantener TODOS los demás errores - especialmente errores de tipos del usuario
+                return true;
             });
             return {
                 diagnostics: filteredDiagnostics,

package/dist/compiler/typescript-worker-thread.cjs

@@ -34,42 +34,43 @@ class WorkerTypeScriptLanguageServiceHost {
     createUltraCleanCompilerOptions(options) {
         // Usar las opciones del tsconfig.json pasadas desde el hilo principal
         const cleanOptions = {
-            target: options.target || ts.ScriptTarget.ES2020,
-            module: options.module || ts.ModuleKind.ES2020,
-            strict: Boolean(options.strict),
-            noEmitOnError: Boolean(options.noEmitOnError),
-            skipLibCheck: Boolean(options.skipLibCheck !== false), // true por defecto
-            skipDefaultLibCheck: Boolean(options.skipDefaultLibCheck !== false), // true por defecto
-            allowJs: Boolean(options.allowJs !== false), // true por defecto
-            esModuleInterop: Boolean(options.esModuleInterop !== false), // true por defecto
-            allowSyntheticDefaultImports: Boolean(
-                options.allowSyntheticDefaultImports !== false,
-            ), // true por defecto
-            declaration: Boolean(options.declaration),
-            sourceMap: Boolean(options.sourceMap),
-            noImplicitAny: Boolean(options.noImplicitAny),
-            noImplicitReturns: Boolean(options.noImplicitReturns),
-            noImplicitThis: Boolean(options.noImplicitThis),
-            noUnusedLocals: Boolean(options.noUnusedLocals),
-            noUnusedParameters: Boolean(options.noUnusedParameters),
-            isolatedModules: Boolean(options.isolatedModules !== false), // true por defecto            // Usar las librerías especificadas en el tsconfig.json
-            lib: Array.isArray(options.lib)
-                ? options.lib
-                : ['es2020', 'dom', 'dom.iterable'],
-
-            // Soporte para decorators
-            experimentalDecorators: Boolean(
-                options.experimentalDecorators !== false,
-            ),
-            emitDecoratorMetadata: Boolean(
-                options.emitDecoratorMetadata !== false,
-            ),
-
-            // Opciones críticas para el worker pero manteniendo compatibilidad
-            noLib: false, // Permitir librerías para APIs básicas (DOM, Promise, etc.)
-            noResolve: true, // Evitar resolución de módulos compleja pero mantener tipos globales
-            suppressOutputPathCheck: true,
-            allowNonTsExtensions: true,
+            // target: options.target || ts.ScriptTarget.ES2020,
+            // module: options.module || ts.ModuleKind.ES2020,
+            // strict: Boolean(options.strict),
+            // noEmitOnError: Boolean(options.noEmitOnError),
+            // skipLibCheck: Boolean(options.skipLibCheck !== false), // true por defecto
+            // skipDefaultLibCheck: Boolean(options.skipDefaultLibCheck !== false), // true por defecto
+            // allowJs: Boolean(options.allowJs !== false), // true por defecto
+            // esModuleInterop: Boolean(options.esModuleInterop !== false), // true por defecto
+            // allowSyntheticDefaultImports: Boolean(
+            //     options.allowSyntheticDefaultImports !== false,
+            // ), // true por defecto
+            // declaration: Boolean(options.declaration),
+            // sourceMap: Boolean(options.sourceMap),
+            // noImplicitAny: Boolean(options.noImplicitAny),
+            // noImplicitReturns: Boolean(options.noImplicitReturns),
+            // noImplicitThis: Boolean(options.noImplicitThis),
+            // noUnusedLocals: Boolean(options.noUnusedLocals),
+            // noUnusedParameters: Boolean(options.noUnusedParameters),
+            // isolatedModules: Boolean(options.isolatedModules !== false), // true por defecto            // Usar las librerías especificadas en el tsconfig.json
+            // lib: Array.isArray(options.lib)
+            //     ? options.lib
+            //     : ['es2020', 'dom', 'dom.iterable'],
+
+            // // Soporte para decorators
+            // experimentalDecorators: Boolean(
+            //     options.experimentalDecorators !== false,
+            // ),
+            // emitDecoratorMetadata: Boolean(
+            //     options.emitDecoratorMetadata !== false,
+            // ),
+
+            // // Opciones críticas para el worker pero manteniendo compatibilidad
+            // noLib: false, // Permitir librerías para APIs básicas (DOM, Promise, etc.)
+            // noResolve: true, // Evitar resolución de módulos compleja pero mantener tipos globales
+            // suppressOutputPathCheck: true,
+            // allowNonTsExtensions: true,
+            ...options,
         };
 
         // console.log(
@@ -200,6 +201,13 @@ function validateTypesInWorker(fileName, content, compilerOptions) {
                     function defineComponent<T>(options: T): T;
                     function defineProps<T = {}>(): T;
                     function defineEmits<T = {}>(): T;
+                    function defineExpose<T = {}>(exposed: T): void;
+                    function mergeModels<T>(models: T): T;
+                    function provide<T>(key: string | symbol, value: T): void;
+                    function inject<T>(key: string | symbol, defaultValue?: T): T | undefined;
+                    function useSlots(): { [key: string]: (...args: any[]) => any };
+                    function useAttrs(): { [key: string]: any };
+                    function useModel<T>(modelName: string): { value: T };
                     function onMounted(fn: () => void): void;
                     function onUnmounted(fn: () => void): void;
                     function watch<T>(source: () => T, callback: (newValue: T, oldValue: T) => void): void;
@@ -282,6 +290,9 @@ function validateTypesInWorker(fileName, content, compilerOptions) {
                 return (
                     !messageText.includes('Cannot find module') &&
                     !messageText.includes('Could not find source file') &&
+                    !messageText.includes(
+                        "has no exported member 'mergeModels'",
+                    ) &&
                     !messageText.includes(
                         "Parameter '$props' implicitly has an 'any' type",
                     ) &&
@@ -310,10 +321,9 @@ function validateTypesInWorker(fileName, content, compilerOptions) {
                     !messageText.includes(
                         'The runtime will invoke the decorator with',
                     ) &&
-                    // Ignorar errores TS7031 (binding element implicitly has any type)
-                    diag.code !== 7031 &&
-                    // Ignorar errores TS7006 (parameter implicitly has any type)
-                    diag.code !== 7006 &&
+                    // NO ignorar errores TS7031 y TS7006 de forma general, solo para parámetros específicos de Vue
+                    // diag.code !== 7031 &&
+                    // diag.code !== 7006 &&
                     // Ignorar errores TS1241 (decorator signature mismatch) durante desarrollo
                     diag.code !== 1241 &&
                     !(

package/dist/compiler/vuejs.js

@@ -1,6 +1,8 @@
 import { createHash } from 'node:crypto';
 import path from 'node:path';
 import * as vCompiler from 'vue/compiler-sfc';
+// Type casting para evitar problemas de tipos con Vue SFC
+const vueCompiler = vCompiler;
 import { logger } from '../servicios/logger.js';
 import { parser } from './parser.js';
 // Lazy loading para chalk
@@ -160,16 +162,16 @@ export const preCompileVue = async (data, source, isProd = false) => {
             const { injectedData } = hmrInjectionCache.getOrGenerateHMRInjection(data, fileName);
             data = injectedData;
         }
-        const { descriptor, errors } = vCompiler.parse(data, {
+        const { descriptor, errors } = vueCompiler.parse(data, {
             filename: fileName,
             sourceMap: !isProd,
             sourceRoot: path.dirname(source),
         });
         if (errors.length) {
-            throw new Error(`Error al analizar el componente Vue ${source}:\n${errors.map(e => e.message).join('\n')}`);
+            throw new Error(`Error al analizar el componente Vue ${source}:\n${errors.map((e) => e.message).join('\n')}`);
         }
         const id = Math.random().toString(36).slice(2, 12);
-        const scopeId = descriptor.styles.some(s => s.scoped)
+        const scopeId = descriptor.styles.some((s) => s.scoped)
             ? `data-v-${id}`
             : null;
         // --- 1. Compilación del Script ---
@@ -200,7 +202,7 @@ export const preCompileVue = async (data, source, isProd = false) => {
                 },
                 customElement: false,
             };
-            const compiledScriptResult = vCompiler.compileScript(descriptor, scriptCompileOptions);
+            const compiledScriptResult = vueCompiler.compileScript(descriptor, scriptCompileOptions);
             scriptContent = compiledScriptResult.content;
             scriptLang =
                 scriptToCompile.lang?.toLowerCase() === 'ts' ||
@@ -251,7 +253,7 @@ export const preCompileVue = async (data, source, isProd = false) => {
                     directiveTransforms: {},
                 },
             };
-            const compiledTemplateResult = vCompiler.compileTemplate(templateCompileOptions);
+            const compiledTemplateResult = vueCompiler.compileTemplate(templateCompileOptions);
             if (compiledTemplateResult.errors?.length > 0) {
                 logger.error('Template compilation errors:', compiledTemplateResult.errors);
             }
@@ -275,7 +277,7 @@ export const preCompileVue = async (data, source, isProd = false) => {
                 descriptor.customBlocks[0]?.content.slice(0, -1) ?? '';
         }
         // Compile styles
-        const compiledStyles = descriptor.styles.map(style => {
+        const compiledStyles = descriptor.styles.map((style) => {
             const lang = style.lang?.toLowerCase();
             let currentPreprocessLang = undefined;
             if (lang === 'scss' ||
@@ -285,7 +287,7 @@ export const preCompileVue = async (data, source, isProd = false) => {
                 lang === 'stylus') {
                 currentPreprocessLang = lang;
             }
-            return vCompiler.compileStyle({
+            return vueCompiler.compileStyle({
                 id,
                 source: style.content,
                 scoped: style.scoped,
@@ -299,7 +301,7 @@ export const preCompileVue = async (data, source, isProd = false) => {
             ? `(function(){
                     let styleTag = document.createElement('style');
                     styleTag.setAttribute('data-v-${id}', '');
-                    styleTag.innerHTML = \`${compiledStyles.map(s => s.code).join('\n')}\`;
+                    styleTag.innerHTML = \`${compiledStyles.map((s) => s.code).join('\n')}\`;
                     document.head.appendChild(styleTag);
                 })();`
             : '';