versacompiler 2.0.4 → 2.0.6

package/dist/compiler/typescript-compiler.js

@@ -4,6 +4,7 @@ import * as process from 'node:process';
 import { env } from 'node:process';
 import * as typescript from 'typescript';
 import { createUnifiedErrorMessage, parseTypeScriptErrors, } from './typescript-error-parser.js';
+import { validateTypesWithLanguageService } from './typescript-sync-validator.js';
 import { TypeScriptWorkerManager } from './typescript-worker.js';
 /**
  * Cache para la configuración de TypeScript para evitar lecturas repetidas
@@ -26,16 +27,8 @@ export const loadTypeScriptConfig = (fileName) => {
         try {
             const { config, error: configError } = typescript.readConfigFile(configPath, typescript.sys.readFile);
             if (!configError) {
-                const parsedConfig = typescript.parseJsonConfigFileContent(config, typescript.sys, path.dirname(configPath));
-                compilerOptions = {
-                    ...parsedConfig.options,
-                    // Asegurar opciones básicas necesarias
-                    allowJs: parsedConfig.options.allowJs !== false,
-                    esModuleInterop: parsedConfig.options.esModuleInterop !== false,
-                    allowSyntheticDefaultImports: parsedConfig.options.allowSyntheticDefaultImports !==
-                        false,
-                    skipLibCheck: parsedConfig.options.skipLibCheck !== false,
-                };
+                const parsedConfig = typescript.parseJsonConfigFileContent(config, typescript.sys, path.dirname(configPath)); // Usar exactamente la configuración del tsconfig.json del usuario
+                compilerOptions = parsedConfig.options;
             }
             else {
                 throw new Error(`Error al leer tsconfig.json: ${configError.messageText}`);
@@ -75,214 +68,14 @@ const getDefaultCompilerOptions = () => ({
  * @returns Opciones serializables seguras para workers
  */
 const createSerializableCompilerOptions = (options) => {
-    // Usar las opciones del tsconfig.json pero con optimizaciones para el worker
-    const { target = typescript.ScriptTarget.ES2020, module = typescript.ModuleKind.ES2020, lib = ['es2020', 'dom', 'dom.iterable'], allowJs = true, jsx, strict = false, skipLibCheck = true, esModuleInterop = true, allowSyntheticDefaultImports = true, isolatedModules = true, } = options;
+    // Respetar completamente la configuración del usuario del tsconfig.json
     return {
-        target,
-        module,
-        lib: Array.isArray(lib) ? lib : ['es2020', 'dom', 'dom.iterable'],
-        allowJs,
-        jsx,
-        strict,
-        skipLibCheck,
-        skipDefaultLibCheck: true,
-        esModuleInterop,
-        allowSyntheticDefaultImports,
-        isolatedModules,
-        noEmitOnError: false,
-        declaration: false,
-        sourceMap: false,
+        ...options,
+        // NO modificar configuraciones del usuario - solo optimizaciones internas del worker que no afectan la validación
+        declaration: false, // No necesitamos declaraciones en el worker
+        sourceMap: false, // No necesitamos source maps en el worker
     };
 };
-/**
- * Crea un Language Service Host optimizado para validación de tipos eficiente.
- */
-class TypeScriptLanguageServiceHost {
-    files = new Map();
-    compilerOptions;
-    fileSystemCache = new Map();
-    constructor(compilerOptions) {
-        this.compilerOptions = compilerOptions;
-    }
-    addFile(fileName, content) {
-        const existing = this.files.get(fileName);
-        this.files.set(fileName, {
-            version: existing ? existing.version + 1 : 1,
-            content,
-        });
-    }
-    getCompilationSettings() {
-        return this.compilerOptions;
-    }
-    getScriptFileNames() {
-        return Array.from(this.files.keys());
-    }
-    getScriptVersion(fileName) {
-        const file = this.files.get(fileName);
-        return file ? file.version.toString() : '0';
-    }
-    getScriptSnapshot(fileName) {
-        const file = this.files.get(fileName);
-        if (file) {
-            return typescript.ScriptSnapshot.fromString(file.content);
-        }
-        // Cache de sistema de archivos para evitar lecturas repetidas
-        if (this.fileSystemCache.has(fileName)) {
-            const cachedContent = this.fileSystemCache.get(fileName);
-            return cachedContent
-                ? typescript.ScriptSnapshot.fromString(cachedContent)
-                : undefined;
-        }
-        // Intentar leer el archivo del sistema de archivos solo si es necesario
-        try {
-            if (fs.existsSync(fileName)) {
-                const content = fs.readFileSync(fileName, 'utf-8');
-                this.fileSystemCache.set(fileName, content);
-                return typescript.ScriptSnapshot.fromString(content);
-            }
-        }
-        catch {
-            // Error al leer archivo
-        }
-        this.fileSystemCache.set(fileName, undefined);
-        return undefined;
-    }
-    getCurrentDirectory() {
-        return process.cwd();
-    }
-    getDefaultLibFileName(options) {
-        return typescript.getDefaultLibFilePath(options);
-    }
-    fileExists(path) {
-        if (this.files.has(path))
-            return true;
-        if (this.fileSystemCache.has(path)) {
-            return this.fileSystemCache.get(path) !== undefined;
-        }
-        const exists = fs.existsSync(path);
-        if (!exists)
-            this.fileSystemCache.set(path, undefined);
-        return exists;
-    }
-    readFile(path) {
-        const file = this.files.get(path);
-        if (file)
-            return file.content;
-        if (this.fileSystemCache.has(path)) {
-            return this.fileSystemCache.get(path);
-        }
-        try {
-            if (fs.existsSync(path)) {
-                const content = fs.readFileSync(path, 'utf-8');
-                this.fileSystemCache.set(path, content);
-                return content;
-            }
-        }
-        catch {
-            // Error al leer archivo
-        }
-        this.fileSystemCache.set(path, undefined);
-        return undefined;
-    }
-    getNewLine() {
-        return typescript.sys.newLine;
-    }
-}
-/**
- * Realiza validación de tipos optimizada usando TypeScript Language Service.
- * @param fileName - Nombre del archivo
- * @param content - Contenido del archivo
- * @param compilerOptions - Opciones del compilador
- * @returns Resultado de la validación de tipos
- */
-const validateTypesWithLanguageService = (fileName, content, compilerOptions) => {
-    try {
-        // Validación temprana: contenido vacío
-        if (!content.trim()) {
-            return { diagnostics: [], hasErrors: false };
-        }
-        // Crear Language Service Host optimizado
-        const host = new TypeScriptLanguageServiceHost(compilerOptions);
-        // Determinar nombre de archivo efectivo
-        let actualFileName = path.isAbsolute(fileName)
-            ? fileName
-            : path.resolve(fileName);
-        // Para archivos Vue, crear archivo virtual
-        if (fileName.endsWith('.vue')) {
-            actualFileName = actualFileName.replace('.vue', '.vue.ts');
-            host.addFile(actualFileName, content);
-            // Añadir declaraciones Vue básicas solo si es necesario
-            const vueTypesPath = path.join(path.dirname(actualFileName), 'vue-types.d.ts');
-            const vueTypesDeclaration = `
-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);
-        }
-        else {
-            host.addFile(actualFileName, content);
-        } // Crear Language Service
-        const languageService = typescript.createLanguageService(host);
-        // Verificar existencia del archivo
-        if (!host.fileExists(actualFileName)) {
-            return { diagnostics: [], hasErrors: false };
-        }
-        // Obtener diagnósticos con manejo de errores optimizado
-        const allDiagnostics = [];
-        try {
-            allDiagnostics.push(...languageService.getSyntacticDiagnostics(actualFileName));
-            allDiagnostics.push(...languageService.getSemanticDiagnostics(actualFileName));
-        }
-        catch {
-            // Ignorar errores de diagnósticos
-            return { diagnostics: [], hasErrors: false };
-        } // Filtrado optimizado de diagnósticos
-        const filteredDiagnostics = allDiagnostics.filter(diag => {
-            if (diag.category !== typescript.DiagnosticCategory.Error)
-                return false;
-            const messageText = typescript.flattenDiagnosticMessageText(diag.messageText, '\n');
-            // Lista optimizada de patrones a ignorar
-            const ignorePatterns = [
-                'Cannot find module',
-                'Could not find source file',
-                "Parameter '$props' implicitly has an 'any' type",
-                "Parameter '$setup' implicitly has an 'any' type",
-                "Parameter '_ctx' implicitly has an 'any' type",
-                "Parameter '_cache' implicitly has an 'any' type",
-            ];
-            return !ignorePatterns.some(pattern => messageText.includes(pattern));
-        });
-        return {
-            diagnostics: filteredDiagnostics,
-            hasErrors: filteredDiagnostics.length > 0,
-        };
-    }
-    catch (error) {
-        // Error handling simplificado
-        return {
-            diagnostics: [
-                {
-                    file: undefined,
-                    start: undefined,
-                    length: undefined,
-                    messageText: `Error en validación de tipos: ${error instanceof Error ? error.message : 'Error desconocido'}`,
-                    category: typescript.DiagnosticCategory.Error,
-                    code: 0,
-                },
-            ],
-            hasErrors: true,
-        };
-    }
-};
 /**
  * Valida tipos en archivos Vue antes de la compilación
  * @param vueContent - Contenido del archivo Vue

package/dist/compiler/typescript-manager.js

@@ -4,6 +4,7 @@ import * as process from 'node:process';
 import { env } from 'node:process';
 import * as typescript from 'typescript';
 import { createUnifiedErrorMessage, parseTypeScriptErrors, } from './typescript-error-parser.js';
+import { validateTypesWithLanguageService } from './typescript-sync-validator.js';
 import { TypeScriptWorkerPool } from './typescript-worker-pool.js';
 /**
  * Cache para la configuración de TypeScript para evitar lecturas repetidas
@@ -15,8 +16,13 @@ let configCache = {};
  * @returns Opciones del compilador TypeScript
  */
 export const loadTypeScriptConfig = (fileName) => {
+    // Siempre buscar primero en la raíz del proyecto
+    const rootConfigPath = path.resolve(process.cwd(), 'tsconfig.json');
+    // Si no existe en la raíz, buscar desde el directorio del archivo
     const fileDir = path.dirname(fileName);
-    const configPath = typescript.findConfigFile(fileDir, typescript.sys.fileExists, 'tsconfig.json') || path.resolve(process.cwd(), 'tsconfig.json');
+    const configPath = fs.existsSync(rootConfigPath)
+        ? rootConfigPath
+        : typescript.findConfigFile(fileDir, typescript.sys.fileExists, 'tsconfig.json');
     // Usar cache si el path no ha cambiado
     if (configCache.path === configPath && configCache.options) {
         return configCache.options;
@@ -26,16 +32,12 @@ export const loadTypeScriptConfig = (fileName) => {
         try {
             const { config, error: configError } = typescript.readConfigFile(configPath, typescript.sys.readFile);
             if (!configError) {
-                const parsedConfig = typescript.parseJsonConfigFileContent(config, typescript.sys, path.dirname(configPath));
-                compilerOptions = {
-                    ...parsedConfig.options,
-                    // Asegurar opciones básicas necesarias
-                    allowJs: parsedConfig.options.allowJs !== false,
-                    esModuleInterop: parsedConfig.options.esModuleInterop !== false,
-                    allowSyntheticDefaultImports: parsedConfig.options.allowSyntheticDefaultImports !==
-                        false,
-                    skipLibCheck: parsedConfig.options.skipLibCheck !== false,
-                };
+                const parsedConfig = typescript.parseJsonConfigFileContent(config, typescript.sys, path.dirname(configPath)); // Usar exactamente la configuración del tsconfig.json del usuario sin modificaciones
+                compilerOptions = parsedConfig.options;
+                // DEBUG: Verificar las opciones cargadas
+                // console.log(`[DEBUG] Opciones de TypeScript cargadas desde ${configPath}:`);
+                // console.log(`  noImplicitAny: ${compilerOptions.noImplicitAny}`);
+                // console.log(`  strict: ${compilerOptions.strict}`);
             }
             else {
                 throw new Error(`Error al leer tsconfig.json: ${configError.messageText}`);
@@ -43,255 +45,124 @@ export const loadTypeScriptConfig = (fileName) => {
         }
         catch (error) {
             console.warn(`[loadTypeScriptConfig] Error cargando ${configPath}:`, error);
-            // Fallback a opciones por defecto
-            compilerOptions = getDefaultCompilerOptions();
+            throw new Error(`No se puede continuar sin un tsconfig.json válido. Error: ${error}`);
         }
     }
     else {
-        // Opciones por defecto si no se encuentra tsconfig.json
-        compilerOptions = getDefaultCompilerOptions();
+        throw new Error(`No se encontró tsconfig.json en la raíz del proyecto (${rootConfigPath}) ni en el directorio del archivo. ` +
+            `El compilador requiere un tsconfig.json para funcionar correctamente.`);
     }
     // Guardar en cache
     configCache = { path: configPath, options: compilerOptions };
     return compilerOptions;
 };
-/**
- * Obtiene las opciones por defecto del compilador TypeScript
- */
-const getDefaultCompilerOptions = () => ({
-    target: typescript.ScriptTarget.ES2020,
-    module: typescript.ModuleKind.ES2020,
-    lib: ['es2020', 'dom', 'dom.iterable'],
-    strict: false,
-    skipLibCheck: true,
-    allowJs: true,
-    esModuleInterop: true,
-    allowSyntheticDefaultImports: true,
-    isolatedModules: true,
-});
 /**
  * Crea una versión optimizada y serializable de las opciones del compilador typescript.
  * @param options - Opciones originales del compilador
  * @returns Opciones serializables seguras para workers
  */
 const createSerializableCompilerOptions = (options) => {
-    // Usar las opciones del tsconfig.json pero con optimizaciones para el worker
-    const { target = typescript.ScriptTarget.ES2020, module = typescript.ModuleKind.ES2020, lib = ['es2020', 'dom', 'dom.iterable'], allowJs = true, jsx, strict = false, skipLibCheck = true, esModuleInterop = true, allowSyntheticDefaultImports = true, isolatedModules = true, } = options;
-    return {
-        target,
-        module,
-        lib: Array.isArray(lib) ? lib : ['es2020', 'dom', 'dom.iterable'],
-        allowJs,
-        jsx,
-        strict,
-        skipLibCheck,
-        skipDefaultLibCheck: true,
-        esModuleInterop,
-        allowSyntheticDefaultImports,
-        isolatedModules,
-        noEmitOnError: false,
-        declaration: false,
-        sourceMap: false,
-    };
+    // Respetar exactamente las opciones del tsconfig.json del usuario    // Respetar completamente la configuración del usuario del tsconfig.json
+    const result = { ...options };
+    // NO modificar ninguna opción del usuario - usar configuración exacta del tsconfig.json
+    return result;
 };
 /**
  * Crea un Language Service Host optimizado para validación de tipos eficiente.
  */
-class TypeScriptLanguageServiceHost {
-    files = new Map();
-    compilerOptions;
-    fileSystemCache = new Map();
-    constructor(compilerOptions) {
-        this.compilerOptions = compilerOptions;
+/**
+ * Valida tipos en archivos Vue antes de la compilación con soporte mejorado
+ * @param vueContent - Contenido del archivo Vue
+ * @param fileName - Nombre del archivo Vue
+ * @param options - Opciones adicionales para la validación
+ * @returns Resultado de la validación de tipos
+ */
+export const validateVueTypes = (vueContent, fileName, options) => {
+    // Extraer contenido del script de Vue
+    let scriptContent = '';
+    if (fileName.endsWith('.vue')) {
+        // Extraer contenido entre <script> y </script>
+        const scriptMatch = vueContent.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+        if (scriptMatch && scriptMatch[1]) {
+            scriptContent = scriptMatch[1].trim();
+        }
+        else {
+            // Si no hay script, no hay nada que validar
+            return { diagnostics: [], hasErrors: false };
+        }
     }
-    addFile(fileName, content) {
-        const existing = this.files.get(fileName);
-        this.files.set(fileName, {
-            version: existing ? existing.version + 1 : 1,
-            content,
-        });
+    else {
+        // Para archivos .ts/.js normales, usar todo el contenido
+        scriptContent = vueContent;
     }
-    getCompilationSettings() {
-        return this.compilerOptions;
+    // Si el script está vacío, no validar
+    if (!scriptContent.trim()) {
+        return { diagnostics: [], hasErrors: false };
     }
-    getScriptFileNames() {
-        return Array.from(this.files.keys());
+    // Cargar la configuración del usuario como base
+    const userConfig = loadTypeScriptConfig(fileName);
+    // Crear opciones del compilador respetando la configuración del usuario
+    let compilerOptions;
+    if (options?.compilerOptions) {
+        // Si se proporcionaron opciones explícitas, usarlas como base
+        compilerOptions = { ...options.compilerOptions };
     }
-    getScriptVersion(fileName) {
-        const file = this.files.get(fileName);
-        return file ? file.version.toString() : '0';
+    else {
+        // Usar la configuración del usuario como base
+        compilerOptions = { ...userConfig };
     }
-    getScriptSnapshot(fileName) {
-        const file = this.files.get(fileName);
-        if (file) {
-            return typescript.ScriptSnapshot.fromString(file.content);
+    // Solo forzar las opciones ABSOLUTAMENTE necesarias para Vue
+    // Estas opciones se fuerzan porque son técnicamente requeridas para el funcionamiento correcto
+    if (fileName.endsWith('.vue')) {
+        // JSX: Necesario para que funcione el template compilation de Vue
+        compilerOptions.jsx = typescript.JsxEmit.Preserve;
+        // ModuleResolution: Necesario para resolver módulos Vue correctamente
+        if (!compilerOptions.moduleResolution) {
+            compilerOptions.moduleResolution =
+                typescript.ModuleResolutionKind.NodeJs;
         }
-        // Cache de sistema de archivos para evitar lecturas repetidas
-        if (this.fileSystemCache.has(fileName)) {
-            const cachedContent = this.fileSystemCache.get(fileName);
-            return cachedContent
-                ? typescript.ScriptSnapshot.fromString(cachedContent)
-                : undefined;
-        }
-        // Intentar leer el archivo del sistema de archivos solo si es necesario
-        try {
-            if (fs.existsSync(fileName)) {
-                const content = fs.readFileSync(fileName, 'utf-8');
-                this.fileSystemCache.set(fileName, content);
-                return typescript.ScriptSnapshot.fromString(content);
-            }
+        // Lib: Asegurar que DOM esté disponible para archivos Vue, pero respetar otras libs del usuario
+        const currentLibs = compilerOptions.lib || userConfig.lib || ['ES2020'];
+        const hasDOM = currentLibs.some(lib => typeof lib === 'string' &&
+            (lib.toLowerCase().includes('dom') ||
+                lib.toLowerCase() === 'dom'));
+        if (!hasDOM) {
+            compilerOptions.lib = [...currentLibs, 'DOM', 'DOM.Iterable'];
         }
-        catch {
-            // Error al leer archivo
+        // Types: Agregar 'vue' si no está presente, pero mantener otros types del usuario
+        const currentTypes = compilerOptions.types || userConfig.types || [];
+        if (!currentTypes.includes('vue')) {
+            compilerOptions.types = [...currentTypes, 'vue'];
         }
-        this.fileSystemCache.set(fileName, undefined);
-        return undefined;
     }
-    getCurrentDirectory() {
-        return process.cwd();
+    // Configuraciones que mejoran la detección de errores pero respetan preferencias del usuario
+    // Solo se aplican si el usuario no las ha configurado explícitamente
+    if (compilerOptions.skipLibCheck === undefined) {
+        compilerOptions.skipLibCheck = true; // Para evitar errores en librerías externas
     }
-    getDefaultLibFileName(options) {
-        return typescript.getDefaultLibFilePath(options);
-    }
-    fileExists(path) {
-        if (this.files.has(path))
-            return true;
-        if (this.fileSystemCache.has(path)) {
-            return this.fileSystemCache.get(path) !== undefined;
-        }
-        const exists = fs.existsSync(path);
-        if (!exists)
-            this.fileSystemCache.set(path, undefined);
-        return exists;
-    }
-    readFile(path) {
-        const file = this.files.get(path);
-        if (file)
-            return file.content;
-        if (this.fileSystemCache.has(path)) {
-            return this.fileSystemCache.get(path);
-        }
-        try {
-            if (fs.existsSync(path)) {
-                const content = fs.readFileSync(path, 'utf-8');
-                this.fileSystemCache.set(path, content);
-                return content;
-            }
+    // Aplicar strictMode solo si el usuario no ha configurado estas opciones individualmente
+    if (options?.strictMode !== undefined) {
+        if (compilerOptions.noImplicitReturns === undefined) {
+            compilerOptions.noImplicitReturns = options.strictMode;
         }
-        catch {
-            // Error al leer archivo
+        if (compilerOptions.noImplicitThis === undefined) {
+            compilerOptions.noImplicitThis = options.strictMode;
         }
-        this.fileSystemCache.set(path, undefined);
-        return undefined;
-    }
-    getNewLine() {
-        return typescript.sys.newLine;
-    }
-}
-/**
- * Realiza validación de tipos optimizada usando TypeScript Language Service.
- * @param fileName - Nombre del archivo
- * @param content - Contenido del archivo
- * @param compilerOptions - Opciones del compilador
- * @returns Resultado de la validación de tipos
- */
-const validateTypesWithLanguageService = (fileName, content, compilerOptions) => {
-    try {
-        // Validación temprana: contenido vacío
-        if (!content.trim()) {
-            return { diagnostics: [], hasErrors: false };
+        if (compilerOptions.strictNullChecks === undefined) {
+            compilerOptions.strictNullChecks = options.strictMode;
         }
-        // Crear Language Service Host optimizado
-        const host = new TypeScriptLanguageServiceHost(compilerOptions);
-        // Determinar nombre de archivo efectivo
-        let actualFileName = path.isAbsolute(fileName)
-            ? fileName
-            : path.resolve(fileName);
-        // Para archivos Vue, crear archivo virtual
-        if (fileName.endsWith('.vue')) {
-            actualFileName = actualFileName.replace('.vue', '.vue.ts');
-            host.addFile(actualFileName, content);
-            // Añadir declaraciones Vue básicas solo si es necesario
-            const vueTypesPath = path.join(path.dirname(actualFileName), 'vue-types.d.ts');
-            const vueTypesDeclaration = `
-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);
+        if (compilerOptions.strictFunctionTypes === undefined) {
+            compilerOptions.strictFunctionTypes = options.strictMode;
         }
-        else {
-            host.addFile(actualFileName, content);
-        } // Crear Language Service
-        const languageService = typescript.createLanguageService(host);
-        // Verificar existencia del archivo
-        if (!host.fileExists(actualFileName)) {
-            return { diagnostics: [], hasErrors: false };
+        if (compilerOptions.exactOptionalPropertyTypes === undefined) {
+            compilerOptions.exactOptionalPropertyTypes = false; // Menos estricto por defecto
         }
-        // Obtener diagnósticos con manejo de errores optimizado
-        const allDiagnostics = [];
-        try {
-            allDiagnostics.push(...languageService.getSyntacticDiagnostics(actualFileName));
-            allDiagnostics.push(...languageService.getSemanticDiagnostics(actualFileName));
+        if (compilerOptions.noFallthroughCasesInSwitch === undefined) {
+            compilerOptions.noFallthroughCasesInSwitch = options.strictMode;
         }
-        catch {
-            // Ignorar errores de diagnósticos
-            return { diagnostics: [], hasErrors: false };
-        } // Filtrado optimizado de diagnósticos
-        const filteredDiagnostics = allDiagnostics.filter(diag => {
-            if (diag.category !== typescript.DiagnosticCategory.Error)
-                return false;
-            const messageText = typescript.flattenDiagnosticMessageText(diag.messageText, '\n');
-            // Lista optimizada de patrones a ignorar
-            const ignorePatterns = [
-                'Cannot find module',
-                'Could not find source file',
-                "Parameter '$props' implicitly has an 'any' type",
-                "Parameter '$setup' implicitly has an 'any' type",
-                "Parameter '_ctx' implicitly has an 'any' type",
-                "Parameter '_cache' implicitly has an 'any' type",
-            ];
-            return !ignorePatterns.some(pattern => messageText.includes(pattern));
-        });
-        return {
-            diagnostics: filteredDiagnostics,
-            hasErrors: filteredDiagnostics.length > 0,
-        };
-    }
-    catch (error) {
-        // Error handling simplificado
-        return {
-            diagnostics: [
-                {
-                    file: undefined,
-                    start: undefined,
-                    length: undefined,
-                    messageText: `Error en validación de tipos: ${error instanceof Error ? error.message : 'Error desconocido'}`,
-                    category: typescript.DiagnosticCategory.Error,
-                    code: 0,
-                },
-            ],
-            hasErrors: true,
-        };
     }
-};
-/**
- * Valida tipos en archivos Vue antes de la compilación
- * @param vueContent - Contenido del archivo Vue
- * @param fileName - Nombre del archivo Vue
- * @returns Resultado de la validación de tipos
- */
-export const validateVueTypes = (vueContent, fileName) => {
-    const compilerOptions = loadTypeScriptConfig(fileName);
-    return validateTypesWithLanguageService(fileName, vueContent, compilerOptions);
+    return validateTypesWithLanguageService(fileName, scriptContent, // Usar solo el contenido del script
+    compilerOptions);
 };
 /**
  * Precompila el código TypeScript con pipeline optimizado para máxima performance.
@@ -340,7 +211,9 @@ export const preCompileTS = async (data, fileName) => {
                 };
             }
         } // PASO 2: Type checking opcional (solo si está habilitado)
+        // console.log(`[DEBUG] env.typeCheck: ${env.typeCheck}`);
         if (env.typeCheck === 'true') {
+            // console.log(`[DEBUG] Iniciando verificación de tipos para: ${fileName}`);
             try {
                 const workerPool = TypeScriptWorkerPool.getInstance();
                 const serializableOptions = createSerializableCompilerOptions(compilerOptions);