versacompiler 2.0.8 → 2.2.0

package/dist/compiler/typescript-manager.js

@@ -1,2 +1,304 @@
-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`}}};
+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
+ * ✨ FIX #9: Ahora incluye timestamp para detectar cambios en el archivo
+ */
+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');
+    // ✨ FIX #9: Verificar si el archivo cambió comparando timestamp
+    if (configPath && fs.existsSync(configPath)) {
+        const stats = fs.statSync(configPath);
+        const currentMtime = stats.mtimeMs;
+        // Usar cache solo si el archivo no cambió
+        if (configCache.path === configPath &&
+            configCache.mtime === currentMtime &&
+            configCache.options) {
+            return configCache.options;
+        }
+    }
+    let compilerOptions;
+    if (configPath && fs.existsSync(configPath)) {
+        const stats = fs.statSync(configPath);
+        const currentMtime = stats.mtimeMs;
+        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}`, { cause: error });
+        }
+        // ✨ FIX #9: Guardar en cache con timestamp
+        configCache = {
+            path: configPath,
+            options: compilerOptions,
+            mtime: currentMtime,
+        };
+        return compilerOptions;
+    }
+    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.`);
+    }
+};
+/**
+ * ✨ FIX #9: Invalida el cache de configuración de TypeScript
+ * Útil cuando se detectan cambios en tsconfig.json o para tests
+ */
+export function invalidateConfigCache() {
+    configCache = {};
+}
+/**
+ * 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 ULTRA RÁPIDA con mínima verificación
+        // Optimizaciones agresivas para máxima velocidad
+        const transpileResult = typescript.transpileModule(data, {
+            compilerOptions: {
+                ...compilerOptions,
+                // Optimizaciones de velocidad
+                noLib: true,
+                skipLibCheck: true,
+                isolatedModules: true,
+                // Deshabilitar checks innecesarios
+                noResolve: true,
+                // ✅ REMOVIDAS opciones obsoletas de TypeScript 5.9:
+                // - suppressImplicitAnyIndexErrors (ya no existe)
+                // - suppressExcessPropertyErrors (ya no existe)
+                allowSyntheticDefaultImports: true,
+                // Modo más rápido
+                incremental: false, // No usar incremental en transpileModule
+                diagnostics: false,
+            },
+            fileName,
+            reportDiagnostics: env.VERBOSE === 'true', // Solo reportar en verbose
+        });
+        // 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)
+        if (env.typeCheck === 'true') {
+            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

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

@@ -1,32 +1,296 @@
-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;
+/**
+ * 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;
+    }
 }
-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);
+/**
+ * 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