versacompiler 2.0.7 → 2.0.8

package/dist/compiler/typescript-manager.js

@@ -1,273 +1,2 @@
-import fs from 'node:fs';
-import path from 'node:path';
-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
- */
-let configCache = {};
-/**
- * Carga la configuración de TypeScript desde tsconfig.json
- * @param fileName - Nombre del archivo para buscar el tsconfig.json relativo
- * @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 = 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;
-    }
-    let compilerOptions;
-    if (configPath && fs.existsSync(configPath)) {
-        try {
-            const { config, error: configError } = typescript.readConfigFile(configPath, typescript.sys.readFile);
-            if (!configError) {
-                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}`);
-            }
-        }
-        catch (error) {
-            console.warn(`[loadTypeScriptConfig] Error cargando ${configPath}:`, error);
-            throw new Error(`No se puede continuar sin un tsconfig.json válido. Error: ${error}`);
-        }
-    }
-    else {
-        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;
-};
-/**
- * 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) => {
-    // 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.
- */
-/**
- * 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 };
-        }
-    }
-    else {
-        // Para archivos .ts/.js normales, usar todo el contenido
-        scriptContent = vueContent;
-    }
-    // Si el script está vacío, no validar
-    if (!scriptContent.trim()) {
-        return { diagnostics: [], hasErrors: false };
-    }
-    // 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 };
-    }
-    else {
-        // Usar la configuración del usuario como base
-        compilerOptions = { ...userConfig };
-    }
-    // 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;
-        }
-        // 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'];
-        }
-        // 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'];
-        }
-    }
-    // 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
-    }
-    // Aplicar strictMode solo si el usuario no ha configurado estas opciones individualmente
-    if (options?.strictMode !== undefined) {
-        if (compilerOptions.noImplicitReturns === undefined) {
-            compilerOptions.noImplicitReturns = options.strictMode;
-        }
-        if (compilerOptions.noImplicitThis === undefined) {
-            compilerOptions.noImplicitThis = options.strictMode;
-        }
-        if (compilerOptions.strictNullChecks === undefined) {
-            compilerOptions.strictNullChecks = options.strictMode;
-        }
-        if (compilerOptions.strictFunctionTypes === undefined) {
-            compilerOptions.strictFunctionTypes = options.strictMode;
-        }
-        if (compilerOptions.exactOptionalPropertyTypes === undefined) {
-            compilerOptions.exactOptionalPropertyTypes = false; // Menos estricto por defecto
-        }
-        if (compilerOptions.noFallthroughCasesInSwitch === undefined) {
-            compilerOptions.noFallthroughCasesInSwitch = options.strictMode;
-        }
-    }
-    return validateTypesWithLanguageService(fileName, scriptContent, // Usar solo el contenido del script
-    compilerOptions);
-};
-/**
- * Limpia los export {} innecesarios que TypeScript agrega automáticamente
- * @param compiledOutput - Código JavaScript compilado
- * @param originalSource - Código TypeScript original
- * @returns Código limpio sin export {} innecesarios
- */
-const cleanupUnnecessaryExports = (compiledOutput, originalSource) => {
-    // Si el output está vacío o solo contiene export {}
-    if (compiledOutput.trim() === 'export {};') {
-        return '';
-    }
-    // Verificar si el código fuente original tiene imports/exports reales
-    const hasRealImportsExports = /(?:^|\s)(?:import|export)\s+(?!(?:\s*\{\s*\}\s*;?\s*$))/m.test(originalSource);
-    // Si no hay imports/exports reales, eliminar export {} del final
-    if (!hasRealImportsExports) {
-        // Buscar el patrón exacto en el archivo
-        const exportPattern = /export\s*\{\s*\}\s*;\s*$/m;
-        const hasExportAtEnd = exportPattern.test(compiledOutput);
-        if (hasExportAtEnd) {
-            return compiledOutput.replace(exportPattern, '');
-        }
-    }
-    return compiledOutput;
-};
-/**
- * Precompila el código TypeScript con pipeline optimizado para máxima performance.
- * @param {string} data - El código TypeScript a precompilar.
- * @param {string} fileName - El nombre del archivo que contiene el código typescript.
- * @returns {Promise<CompileResult>} - Un objeto con el código precompilado o un error.
- */
-export const preCompileTS = async (data, fileName) => {
-    try {
-        // Validación temprana: contenido vacío
-        if (!data.trim()) {
-            return { error: null, data: data, lang: 'ts' };
-        }
-        // Cargar configuración de TypeScript desde tsconfig.json
-        const compilerOptions = loadTypeScriptConfig(fileName); // PASO 1: Transpilación rápida con detección de errores críticos
-        const transpileResult = typescript.transpileModule(data, {
-            compilerOptions: {
-                ...compilerOptions,
-                noLib: true,
-                skipLibCheck: true,
-                isolatedModules: true,
-            },
-            fileName,
-            reportDiagnostics: true,
-        });
-        // const transpileResult = traspileTStoJS(
-        //     fileName,data)
-        // Verificar errores críticos de sintaxis
-        if (transpileResult.diagnostics?.length) {
-            const criticalErrors = transpileResult.diagnostics.filter((diag) => {
-                if (diag.category !== typescript.DiagnosticCategory.Error)
-                    return false;
-                const messageText = typescript.flattenDiagnosticMessageText(diag.messageText, '\n');
-                // Ignorar errores de módulo no encontrado
-                return (!messageText.includes('Cannot find module') &&
-                    !messageText.includes('Could not find source file') &&
-                    diag.code !== 2307 &&
-                    diag.code !== 6059);
-            });
-            if (criticalErrors.length > 0) {
-                const errorMessage = createUnifiedErrorMessage(parseTypeScriptErrors(criticalErrors, fileName, data));
-                return {
-                    error: new Error(errorMessage),
-                    data: null,
-                    lang: 'ts',
-                };
-            }
-        } // 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);
-                const typeCheckResult = await workerPool.typeCheck(fileName, data, serializableOptions);
-                if (typeCheckResult.hasErrors) {
-                    const errorMessage = createUnifiedErrorMessage(parseTypeScriptErrors(typeCheckResult.diagnostics, fileName, data));
-                    return {
-                        error: new Error(errorMessage),
-                        data: null,
-                        lang: 'ts',
-                    };
-                }
-            }
-            catch (typeCheckError) {
-                // Type checking falla, pero continuar con transpilación
-                console.warn('[preCompileTS] ❌ Type checking falló, usando transpilación sin verificación de tipos:', typeCheckError);
-            }
-        }
-        // PASO 3: Devolver resultado optimizado
-        let output = transpileResult.outputText;
-        // Limpiar export {} innecesarios
-        output = cleanupUnnecessaryExports(output, data);
-        return { error: null, data: output, lang: 'ts' };
-    }
-    catch (error) {
-        return {
-            error: error instanceof Error ? error : new Error('Error desconocido'),
-            data: null,
-            lang: 'ts',
-        };
-    }
-};
-//# sourceMappingURL=typescript-manager.js.map
+import e from"node:fs";import i from"node:path";import*as a from"node:process";import{env as o}from"node:process";import*as s from"typescript";import{createUnifiedErrorMessage as c,parseTypeScriptErrors as l}from"./typescript-error-parser.js";import{validateTypesWithLanguageService as u}from"./typescript-sync-validator.js";import{TypeScriptWorkerPool as d}from"./typescript-worker-pool.js";let f={};export const loadTypeScriptConfig=o=>{let c=i.resolve(a.cwd(),`tsconfig.json`),l=i.dirname(o),u=e.existsSync(c)?c:s.findConfigFile(l,s.sys.fileExists,`tsconfig.json`);if(f.path===u&&f.options)return f.options;let d;if(u&&e.existsSync(u))try{let{config:e,error:a}=s.readConfigFile(u,s.sys.readFile);if(a)throw Error(`Error al leer tsconfig.json: ${a.messageText}`);{let a=s.parseJsonConfigFileContent(e,s.sys,i.dirname(u));d=a.options}}catch(e){throw console.warn(`[loadTypeScriptConfig] Error cargando ${u}:`,e),Error(`No se puede continuar sin un tsconfig.json válido. Error: ${e}`)}else throw Error(`No se encontró tsconfig.json en la raíz del proyecto (${c}) ni en el directorio del archivo. El compilador requiere un tsconfig.json para funcionar correctamente.`);return f={path:u,options:d},d};const p=e=>{let i={...e};return i};export const validateVueTypes=(e,i,a)=>{let o=``;if(i.endsWith(`.vue`)){let i=e.match(/<script[^>]*>([\s\S]*?)<\/script>/i);if(i&&i[1])o=i[1].trim();else return{diagnostics:[],hasErrors:!1}}else o=e;if(!o.trim())return{diagnostics:[],hasErrors:!1};let c=loadTypeScriptConfig(i),l;if(l=a?.compilerOptions?{...a.compilerOptions}:{...c},i.endsWith(`.vue`)){l.jsx=s.JsxEmit.Preserve,l.moduleResolution||=s.ModuleResolutionKind.NodeJs;let e=l.lib||c.lib||[`ES2020`],i=e.some(e=>typeof e==`string`&&(e.toLowerCase().includes(`dom`)||e.toLowerCase()===`dom`));i||(l.lib=[...e,`DOM`,`DOM.Iterable`]);let a=l.types||c.types||[];a.includes(`vue`)||(l.types=[...a,`vue`])}return l.skipLibCheck===void 0&&(l.skipLibCheck=!0),a?.strictMode!==void 0&&(l.noImplicitReturns===void 0&&(l.noImplicitReturns=a.strictMode),l.noImplicitThis===void 0&&(l.noImplicitThis=a.strictMode),l.strictNullChecks===void 0&&(l.strictNullChecks=a.strictMode),l.strictFunctionTypes===void 0&&(l.strictFunctionTypes=a.strictMode),l.exactOptionalPropertyTypes===void 0&&(l.exactOptionalPropertyTypes=!1),l.noFallthroughCasesInSwitch===void 0&&(l.noFallthroughCasesInSwitch=a.strictMode)),u(i,o,l)};const m=(e,i)=>{if(e.trim()===`export {};`)return``;let a=/(?:^|\s)(?:import|export)\s+(?!(?:\s*\{\s*\}\s*;?\s*$))/m.test(i);if(!a){let i=/export\s*\{\s*\}\s*;\s*$/m,a=i.test(e);if(a)return e.replace(i,``)}return e};export const preCompileTS=async(e,i)=>{try{if(!e.trim())return{error:null,data:e,lang:`ts`};let a=loadTypeScriptConfig(i),u=s.transpileModule(e,{compilerOptions:{...a,noLib:!0,skipLibCheck:!0,isolatedModules:!0},fileName:i,reportDiagnostics:!0});if(u.diagnostics?.length){let a=u.diagnostics.filter(e=>{if(e.category!==s.DiagnosticCategory.Error)return!1;let i=s.flattenDiagnosticMessageText(e.messageText,`
+`);return!i.includes(`Cannot find module`)&&!i.includes(`Could not find source file`)&&e.code!==2307&&e.code!==6059});if(a.length>0){let o=c(l(a,i,e));return{error:Error(o),data:null,lang:`ts`}}}if(o.typeCheck===`true`)try{let o=d.getInstance(),s=p(a),u=await o.typeCheck(i,e,s);if(u.hasErrors){let a=c(l(u.diagnostics,i,e));return{error:Error(a),data:null,lang:`ts`}}}catch(e){console.warn(`[preCompileTS] ❌ Type checking falló, usando transpilación sin verificación de tipos:`,e)}let f=u.outputText;return f=m(f,e),{error:null,data:f,lang:`ts`}}catch(e){return{error:e instanceof Error?e:Error(`Error desconocido`),data:null,lang:`ts`}}};

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

@@ -1,296 +1,32 @@
-/**
- * TypeScript Sync Validator - Validación síncrona de tipos como fallback
- * Contiene la lógica extraída del módulo principal para cuando el worker no está disponible
- */
-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
- */
-class TypeScriptLanguageServiceHost {
-    files = new Map();
-    compilerOptions;
-    constructor(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);
-        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);
-        } // Intentar leer el archivo del sistema de archivos para dependencias
-        if (fs.existsSync(fileName)) {
-            try {
-                const content = fs.readFileSync(fileName, 'utf-8');
-                return typescript.ScriptSnapshot.fromString(content);
-            }
-            catch {
-                return undefined;
-            }
-        }
-        return undefined;
-    }
-    getCurrentDirectory() {
-        return process.cwd();
-    }
-    getDefaultLibFileName(options) {
-        return typescript.getDefaultLibFilePath(options);
-    }
-    fileExists(path) {
-        return this.files.has(path) || fs.existsSync(path);
-    }
-    readFile(path) {
-        const file = this.files.get(path);
-        if (file) {
-            return file.content;
-        }
-        if (fs.existsSync(path)) {
-            try {
-                return fs.readFileSync(path, 'utf-8');
-            }
-            catch {
-                return undefined;
-            }
-        }
-        return undefined;
-    }
-    getNewLine() {
-        return typescript.sys.newLine;
-    }
+import*as e from"node:fs";import*as t from"node:path";import*as n from"node:process";import*as r from"typescript";const i=()=>`// 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;
 }
-/**
- * Realiza validación de tipos usando TypeScript Language Service (versión síncrona)
- * @param fileName - Nombre del archivo
- * @param content - Contenido del archivo
- * @param compilerOptions - Opciones del compilador
- * @returns Resultado de la validación de tipos
- */
-export const validateTypesWithLanguageService = (fileName, content, compilerOptions) => {
-    try {
-        // Si el script está vacío o es solo espacios en blanco, no validar
-        if (!content.trim()) {
-            return { diagnostics: [], hasErrors: false };
-        } // Crear Language Service Host
-        const host = new TypeScriptLanguageServiceHost(compilerOptions);
-        // Para archivos Vue, crear un archivo virtual .ts
-        let actualFileName = fileName;
-        if (fileName.endsWith('.vue')) {
-            // Crear un nombre de archivo virtual con extensión .ts
-            actualFileName = fileName.replace('.vue', '.vue.ts');
-        }
-        // 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')) {
-            // 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
-            let syntacticDiagnostics = [];
-            let semanticDiagnostics = [];
-            try {
-                syntacticDiagnostics =
-                    languageService.getSyntacticDiagnostics(actualFileName);
-            }
-            catch {
-                // Ignorar errores de diagnósticos sintácticos
-            }
-            try {
-                semanticDiagnostics =
-                    languageService.getSemanticDiagnostics(actualFileName);
-            }
-            catch {
-                // Ignorar errores de diagnósticos semánticos
-            }
-            // Combinar todos los diagnósticos
-            const allDiagnostics = [
-                ...syntacticDiagnostics,
-                ...semanticDiagnostics,
-            ];
-            // 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 (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;
-                    }
-                }
-                // Mantener TODOS los demás errores - especialmente errores de tipos del usuario
-                return true;
-            });
-            return {
-                diagnostics: filteredDiagnostics,
-                hasErrors: filteredDiagnostics.length > 0,
-            };
-        }
-        catch {
-            return { diagnostics: [], hasErrors: false };
-        }
-    }
-    catch (error) {
-        // En caso de error, devolver diagnóstico de error
-        const errorDiagnostic = {
-            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,
-        };
-        return {
-            diagnostics: [errorDiagnostic],
-            hasErrors: true,
-        };
-    }
-};
-/**
- * Valida tipos en archivos Vue antes de la compilación (versión síncrona)
- * @param vueContent - Contenido del archivo Vue
- * @param fileName - Nombre del archivo Vue
- * @param compilerOptions - Opciones del compilador
- * @returns Resultado de la validación de tipos
- */
-export const validateVueTypes = (vueContent, fileName, compilerOptions) => {
-    return validateTypesWithLanguageService(fileName, vueContent, compilerOptions);
-};
-//# sourceMappingURL=typescript-sync-validator.js.map
+declare module '*.vue' {
+    const component: any;
+    export default component;
+}
+export {};`;class a{files=new Map;compilerOptions;constructor(e){this.compilerOptions={...e,lib:e.lib||[`ES2020`,`DOM`,`DOM.Iterable`]}}addFile(e,t){let n=this.files.get(e);this.files.set(e,{version:n?n.version+1:1,content:t})}getCompilationSettings(){return this.compilerOptions}getScriptFileNames(){return Array.from(this.files.keys())}getScriptVersion(e){let t=this.files.get(e);return t?t.version.toString():`0`}getScriptSnapshot(t){let n=this.files.get(t);if(n)return r.ScriptSnapshot.fromString(n.content);if(e.existsSync(t))try{let n=e.readFileSync(t,`utf-8`);return r.ScriptSnapshot.fromString(n)}catch{return}}getCurrentDirectory(){return n.cwd()}getDefaultLibFileName(e){return r.getDefaultLibFilePath(e)}fileExists(t){return this.files.has(t)||e.existsSync(t)}readFile(t){let n=this.files.get(t);if(n)return n.content;if(e.existsSync(t))try{return e.readFileSync(t,`utf-8`)}catch{return}}getNewLine(){return r.sys.newLine}}export const validateTypesWithLanguageService=(o,s,c)=>{try{if(!s.trim())return{diagnostics:[],hasErrors:!1};let l=new a(c),u=o;if(o.endsWith(`.vue`)&&(u=o.replace(`.vue`,`.vue.ts`)),l.addFile(u,s),o.endsWith(`.vue`)){let r=n.cwd(),a=t.join(r,`src/types/vue-shims.d.ts`);try{if(e.existsSync(a)){let t=e.readFileSync(a,`utf-8`);l.addFile(a,t)}else{let e=i(),n=t.join(t.dirname(o),`vue-fallback.d.ts`);l.addFile(n,e)}}catch(e){console.warn(`Error al cargar tipos Vue:`,e);let n=i(),r=t.join(t.dirname(o),`vue-fallback.d.ts`);l.addFile(r,n)}}let d=r.createLanguageService(l);try{if(!l.fileExists(u))return console.log(`File does not exist in host, returning empty result`),{diagnostics:[],hasErrors:!1};let e=[],t=[];try{e=d.getSyntacticDiagnostics(u)}catch{}try{t=d.getSemanticDiagnostics(u)}catch{}let n=[...e,...t],i=n.filter(e=>{let t=r.flattenDiagnosticMessageText(e.messageText,`
+`);if(e.category!==r.DiagnosticCategory.Error)return!1;let n=[`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'`,`Do you need to change your target library`];for(let e of n)if(t.includes(e))return!1;let i=[1241,2307,2584,6133];if(i.includes(e.code))return!1;if(o.endsWith(`.vue`)){let e=[`$props`,`$setup`,`$data`,`$options`,`$event`,`_ctx`,`_cache`,`__expose`,`__emit`,`__slots`,`__props`,`__defaults`];if(t.includes(`implicitly has an 'any' type`)){let n=e.some(e=>t.includes(`'${e}'`)||t.includes(`"${e}"`));if(n)return!1}if(t.includes(`Parameter`)&&t.includes(`implicitly has an`)&&e.some(e=>t.includes(e)))return!1}return!0});return{diagnostics:i,hasErrors:i.length>0}}catch{return{diagnostics:[],hasErrors:!1}}}catch(e){let t={file:void 0,start:void 0,length:void 0,messageText:`Error en validación de tipos: ${e instanceof Error?e.message:`Error desconocido`}`,category:r.DiagnosticCategory.Error,code:0};return{diagnostics:[t],hasErrors:!0}}};export const validateVueTypes=(e,t,n)=>validateTypesWithLanguageService(t,e,n);