versacompiler 2.1.0 → 2.2.0

package/dist/compiler/error-reporter.js

@@ -1,38 +1,467 @@
-let e;function t(){function e(){let t=e=>String(e),n=`reset.bold.dim.italic.underline.strikethrough.inverse.hidden.visible.black.red.green.yellow.blue.magenta.cyan.white.gray.grey.blackBright.redBright.greenBright.yellowBright.blueBright.magentaBright.cyanBright.whiteBright.bgBlack.bgRed.bgGreen.bgYellow.bgBlue.bgMagenta.bgCyan.bgWhite.bgGray.bgGrey.bgBlackBright.bgRedBright.bgGreenBright.bgYellowBright.bgBlueBright.bgMagentaBright.bgCyanBright.bgWhiteBright`.split(`.`);return n.forEach(n=>{Object.defineProperty(t,n,{get(){return e()},enumerable:!0,configurable:!0})}),new Proxy(t,{apply(e,t,n){return String(n[0]||``)},get(t,r){if(typeof r==`string`||typeof r==`symbol`)return typeof r==`string`&&n.includes(r)?e():t[r]}})}return e()}function n(){return e||(e=t()),e}export class ErrorReporter{options;constructor(e={}){this.options={showLineNumbers:e.showLineNumbers??!0,showCodeContext:e.showCodeContext??!0,contextLines:e.contextLines??2,colorize:e.colorize??!0}}analyzeParsingError(e,t,n){let r={file:n,message:e.message||`Error de parsing desconocido`,severity:`error`};if(e.labels&&e.labels.length>0){let n=e.labels[0];if(n.start!==void 0){let e=this.getLineAndColumnFromOffset(t,n.start);r.line=e.line,r.column=e.column}}else if(e.span){let n=this.getLineAndColumnFromSpan(t,e.span.start);r.line=n.line,r.column=n.column}else if(e.offset!==void 0){let n=this.getLineAndColumnFromOffset(t,e.offset);r.line=n.line,r.column=n.column}return this.options.showCodeContext&&r.line&&t&&(r.codeContext=this.generateCodeContext(t,r.line,r.column)),r.suggestion=this.generateIntelligentSuggestion(e.message,t,r.line,r.column),e.code&&(r.errorCode=e.code),e.codeframe&&(r.codeContext=this.combineWithOxcCodeframe(r.codeContext,e.codeframe)),r}getLineAndColumnFromSpan(e,t){return this.getLineAndColumnFromOffset(e,t)}getLineAndColumnFromOffset(e,t){let n=e.split(`
-`),r=0,i=1,a=1;for(let e=0;e<n.length;e++){let o=n[e];if(o===void 0)continue;let s=o.length+1;if(r+s>t){i=e+1,a=t-r+1;break}r+=s}return{line:i,column:a}}generateCodeContext(e,t,r){let i=e.split(`
-`),a=Math.max(1,t-this.options.contextLines),o=Math.min(i.length,t+this.options.contextLines),s=n(),c=`
-`+s.dim(`Contexto del código:`)+`
-`;for(let e=a;e<=o;e++){let n=i[e-1]||``,a=e.toString().padStart(3,` `);if(e===t){if(this.options.colorize){if(c+=s.red(`${a} ❌ ${n}\n`),r){let e=` `.repeat(6+(r-1)),t=s.red(`^`);c+=`${e}${t}\n`}}else if(c+=`${a} ❌ ${n}\n`,r){let e=` `.repeat(6+(r-1));c+=`${e}^\n`}}else{let e=this.options.colorize?s.dim:e=>e;c+=e(`${a}    ${n}\n`)}}return c}generateSuggestion(e){let t=e.toLowerCase();if(t.includes(`unexpected`)&&t.includes(`identifier`))return`Verifica si hay una coma faltante antes del identificador o si la línea anterior no está completa.`;if(t.includes(`expected`)&&t.includes(`but found`))return`Revisa la sintaxis alrededor de este punto. Puede faltar un carácter específico.`;if(t.includes(`missing`)){if(t.includes(`semicolon`))return`Agrega un punto y coma (;) al final de la declaración.`;if(t.includes(`comma`))return`Verifica si falta una coma (,) en una lista o declaración.`;if(t.includes(`parenthesis`))return`Verifica que los paréntesis estén balanceados.`}return t.includes(`import`)||t.includes(`export`)?`Revisa la sintaxis de import/export. Las líneas pueden estar cortadas o malformadas.`:t.includes(`const`)&&t.includes(`initializer`)?`Las declaraciones const requieren un valor inicial. Ejemplos válidos:
-   • const variable = "valor";
-   • const numero = 42;
-   • const objeto = { propiedad: "valor" };`:`Revisa la sintaxis del código alrededor de esta ubicación.`}combineWithOxcCodeframe(e,t){if(!e)return t;let r=n();return e+`
-`+r.dim(`Codeframe de oxc-parser:`)+`
-`+t}formatError(e){let t=``,r=e.severity.toUpperCase(),i=n(),a=e.severity===`error`?i.red:e.severity===`warning`?i.yellow:i.blue;if(this.options.colorize?t+=a(`[${r}]`)+` en ${i.cyan(e.file)}`:t+=`[${r}] en ${e.file}`,e.line){let n=e.column?`línea ${e.line}, columna ${e.column}`:`línea ${e.line}`;this.options.colorize?t+=` (${i.dim(n)})`:t+=` (${n})`}return t+=`
-`,this.options.colorize?t+=`💥 ${i.bold(e.message)}\n`:t+=`💥 ${e.message}\n`,e.errorCode&&(this.options.colorize?t+=i.dim(`   Código: ${e.errorCode}\n`):t+=`   Código: ${e.errorCode}\n`),e.codeContext&&(t+=e.codeContext),e.suggestion&&(this.options.colorize?t+=`\n💡 ${i.yellow(`Sugerencia:`)} ${e.suggestion}\n`:t+=`\n💡 Sugerencia: ${e.suggestion}\n`),t}analyzeMultipleErrors(e,t,n){return e.map(e=>this.analyzeParsingError(e,t,n))}formatMultipleErrors(e){if(e.length===0)return`No se encontraron errores.`;let t=n(),r=``;return this.options.colorize?r+=t.bold.red(`\n🚨 Se encontraron ${e.length} error(es) de parsing:\n\n`):r+=`\n🚨 Se encontraron ${e.length} error(es) de parsing:\n\n`,e.forEach((n,i)=>{r+=this.formatError(n),i<e.length-1&&(this.options.colorize?r+=t.dim(`─`.repeat(60))+`
-
-`:r+=`─`.repeat(60)+`
-
-`)}),r}generateIntelligentSuggestion(e,t,n,r){let i=e.toLowerCase();if(n&&t){let e=t.split(`
-`),r=e[n-1]||``,a=n>1&&e[n-2]||``;if(i.includes(`const`)&&i.includes(`initializer`))return r.trim().match(/^const\s+[a-zA-Z_][a-zA-Z0-9_]*\s*;/)?`Declaración const incompleta. Agrega un valor inicial:
-   • const `+r.match(/const\s+([a-zA-Z_][a-zA-Z0-9_]*)/)?.[1]+` = "valor";
-   • const `+r.match(/const\s+([a-zA-Z_][a-zA-Z0-9_]*)/)?.[1]+` = 42;
-   • O cambia a "let" si planeas asignar después`:r.includes(`=`)&&!r.trim().endsWith(`;`)?`Parece que la declaración const está incompleta. Verifica:
-   • Que la expresión del lado derecho esté completa
-   • Que termine con punto y coma (;)
-   • Que no falten paréntesis o comillas`:`Las declaraciones const requieren un valor inicial:
-   • const variable = "valor";
-   • const numero = 42;
-   • const objeto = { propiedad: "valor" };
-   • const array = [1, 2, 3];`;if(i.includes(`unexpected`)&&i.includes(`identifier`)){if(a.trim()&&!a.trim().endsWith(`;`)&&!a.trim().endsWith(`{`)&&!a.trim().endsWith(`}`))return`La línea anterior parece incompleta. Verifica:
-   • Que termine con punto y coma (;)
-   • Que no falten operadores o comas
-   • Que los paréntesis estén balanceados`;if(r.includes(`,`)&&!r.includes(`=`))return`Posible error en declaración de múltiples variables:
-   • const a = 1, b = 2; (para const)
-   • let a, b; a = 1; b = 2; (para let)
-   • Verifica que cada variable tenga su valor asignado`}if(i.includes(`import`)||i.includes(`export`)){if(r.includes(`import`)&&!r.includes(`from`))return`Import statement incompleto:
-   • import { item } from "modulo";
-   • import defaultItem from "modulo";
-   • import * as alias from "modulo";`;if(r.includes(`export`)&&r.trim().endsWith(`export`))return`Export statement incompleto:
-   • export { item };
-   • export default item;
-   • export const item = valor;`}if(i.includes(`expected`)){let e=(r.match(/\(/g)||[]).length,t=(r.match(/\)/g)||[]).length,n=(r.match(/\{/g)||[]).length,i=(r.match(/\}/g)||[]).length;if(e!==t)return`Paréntesis desbalanceados (${e} abiertos, ${t} cerrados):\n   • Verifica que cada ( tenga su correspondiente )\n   • Revisa llamadas a funciones y expresiones`;if(n!==i)return`Llaves desbalanceadas (${n} abiertas, ${i} cerradas):\n   • Verifica que cada { tenga su correspondiente }\n   • Revisa objetos, funciones y bloques de código`}}return this.generateSuggestion(e)}}export const defaultErrorReporter=new ErrorReporter({showLineNumbers:!0,showCodeContext:!0,contextLines:2,colorize:!0});export function analyzeAndFormatError(e,t,n,a){let o=a?new ErrorReporter(a):defaultErrorReporter,s=o.analyzeParsingError(e,t,n);return o.formatError(s)}export function analyzeAndFormatMultipleErrors(e,t,n,a){let o=a?new ErrorReporter(a):defaultErrorReporter,s=o.analyzeMultipleErrors(e,t,n);return o.formatMultipleErrors(s)}
+// Lazy loading optimizations - Only import lightweight modules synchronously
+// Heavy dependencies will be loaded dynamically when needed
+let chalk;
+// Función que proporciona chalk sin color como fallback
+function createChalkFallback() {
+    // Crear una función que siempre retorna el texto sin modificar
+    function createChainableFunction() {
+        const fn = (text) => String(text);
+        // Lista de métodos de chalk que deben ser encadenables
+        const methods = [
+            'reset',
+            'bold',
+            'dim',
+            'italic',
+            'underline',
+            'strikethrough',
+            'inverse',
+            'hidden',
+            'visible',
+            'black',
+            'red',
+            'green',
+            'yellow',
+            'blue',
+            'magenta',
+            'cyan',
+            'white',
+            'gray',
+            'grey',
+            'blackBright',
+            'redBright',
+            'greenBright',
+            'yellowBright',
+            'blueBright',
+            'magentaBright',
+            'cyanBright',
+            'whiteBright',
+            'bgBlack',
+            'bgRed',
+            'bgGreen',
+            'bgYellow',
+            'bgBlue',
+            'bgMagenta',
+            'bgCyan',
+            'bgWhite',
+            'bgGray',
+            'bgGrey',
+            'bgBlackBright',
+            'bgRedBright',
+            'bgGreenBright',
+            'bgYellowBright',
+            'bgBlueBright',
+            'bgMagentaBright',
+            'bgCyanBright',
+            'bgWhiteBright',
+        ];
+        // Añadir todos los métodos como propiedades que retornan nuevas funciones encadenables
+        methods.forEach(method => {
+            Object.defineProperty(fn, method, {
+                get() {
+                    return createChainableFunction();
+                },
+                enumerable: true,
+                configurable: true,
+            });
+        });
+        // Hacer que la función misma sea callable
+        return new Proxy(fn, {
+            apply(target, thisArg, argumentsList) {
+                return String(argumentsList[0] || '');
+            },
+            get(target, prop) {
+                // Verificar si es una propiedad de la función
+                if (typeof prop === 'string' || typeof prop === 'symbol') {
+                    // Si es un método de chalk, retorna una nueva función encadenable
+                    if (typeof prop === 'string' && methods.includes(prop)) {
+                        return createChainableFunction();
+                    }
+                    // Retornar propiedades existentes de la función
+                    return target[prop];
+                }
+                return undefined;
+            },
+        });
+    }
+    return createChainableFunction();
+}
+// Obtener chalk de forma síncrona con fallback
+function getChalkSync() {
+    if (!chalk) {
+        // Si no tenemos chalk cargado, usar fallback
+        chalk = createChalkFallback();
+    }
+    return chalk;
+}
+/**
+ * Clase para generar reportes detallados de errores de parsing
+ */
+export class ErrorReporter {
+    options;
+    constructor(options = {}) {
+        this.options = {
+            showLineNumbers: options.showLineNumbers ?? true,
+            showCodeContext: options.showCodeContext ?? true,
+            contextLines: options.contextLines ?? 2,
+            colorize: options.colorize ?? true,
+        };
+    }
+    /**
+     * Analiza un error de oxc-parser y extrae información detallada
+     */
+    analyzeParsingError(error, sourceCode, fileName) {
+        const detailedError = {
+            file: fileName,
+            message: error.message || 'Error de parsing desconocido',
+            severity: 'error',
+        };
+        // Intentar extraer información de ubicación del error
+        if (error.labels && error.labels.length > 0) {
+            // oxc-parser proporciona información en labels
+            const label = error.labels[0];
+            if (label.start !== undefined) {
+                const position = this.getLineAndColumnFromOffset(sourceCode, label.start);
+                detailedError.line = position.line;
+                detailedError.column = position.column;
+            }
+        }
+        else if (error.span) {
+            // oxc-parser también puede proporcionar información de span
+            const position = this.getLineAndColumnFromSpan(sourceCode, error.span.start);
+            detailedError.line = position.line;
+            detailedError.column = position.column;
+        }
+        else if (error.offset !== undefined) {
+            // Si tenemos un offset, calculamos línea y columna
+            const position = this.getLineAndColumnFromOffset(sourceCode, error.offset);
+            detailedError.line = position.line;
+            detailedError.column = position.column;
+        }
+        // Agregar contexto del código si está disponible
+        if (this.options.showCodeContext && detailedError.line && sourceCode) {
+            detailedError.codeContext = this.generateCodeContext(sourceCode, detailedError.line, detailedError.column);
+        }
+        // Detectar patrones específicos de errores para sugerencias más inteligentes
+        detailedError.suggestion = this.generateIntelligentSuggestion(error.message, sourceCode, detailedError.line, detailedError.column);
+        // Extraer código de error si está disponible
+        if (error.code) {
+            detailedError.errorCode = error.code;
+        }
+        // Si oxc-parser ya proporciona un codeframe, usarlo como referencia adicional
+        if (error.codeframe) {
+            detailedError.codeContext = this.combineWithOxcCodeframe(detailedError.codeContext, error.codeframe);
+        }
+        return detailedError;
+    }
+    /**
+     * Calcula línea y columna desde un span de oxc-parser
+     */
+    getLineAndColumnFromSpan(sourceCode, spanStart) {
+        return this.getLineAndColumnFromOffset(sourceCode, spanStart);
+    }
+    /**
+     * Calcula línea y columna desde un offset
+     */
+    getLineAndColumnFromOffset(sourceCode, offset) {
+        const lines = sourceCode.split('\n');
+        let currentOffset = 0;
+        let line = 1;
+        let column = 1;
+        for (let i = 0; i < lines.length; i++) {
+            const currentLine = lines[i];
+            if (currentLine === undefined)
+                continue;
+            const lineLength = currentLine.length + 1; // +1 para el \n
+            if (currentOffset + lineLength > offset) {
+                line = i + 1;
+                column = offset - currentOffset + 1;
+                break;
+            }
+            currentOffset += lineLength;
+        }
+        return { line, column };
+    }
+    /**
+     * Genera contexto del código alrededor del error
+     */
+    generateCodeContext(sourceCode, errorLine, errorColumn) {
+        const lines = sourceCode.split('\n');
+        const startLine = Math.max(1, errorLine - this.options.contextLines);
+        const endLine = Math.min(lines.length, errorLine + this.options.contextLines);
+        const chalkSync = getChalkSync();
+        let context = '\n' + chalkSync.dim('Contexto del código:') + '\n';
+        for (let i = startLine; i <= endLine; i++) {
+            const lineContent = lines[i - 1] || '';
+            const lineNumber = i.toString().padStart(3, ' ');
+            const isErrorLine = i === errorLine;
+            if (isErrorLine) {
+                if (this.options.colorize) {
+                    context += chalkSync.red(`${lineNumber} ❌ ${lineContent}\n`);
+                    // Agregar flecha apuntando al error si tenemos la columna
+                    if (errorColumn) {
+                        const spaces = ' '.repeat(6 + (errorColumn - 1));
+                        const arrow = chalkSync.red('^');
+                        context += `${spaces}${arrow}\n`;
+                    }
+                }
+                else {
+                    context += `${lineNumber} ❌ ${lineContent}\n`;
+                    if (errorColumn) {
+                        const spaces = ' '.repeat(6 + (errorColumn - 1));
+                        context += `${spaces}^\n`;
+                    }
+                }
+            }
+            else {
+                const prefix = this.options.colorize
+                    ? chalkSync.dim
+                    : (s) => s;
+                context += prefix(`${lineNumber}    ${lineContent}\n`);
+            }
+        }
+        return context;
+    }
+    /**
+     * Genera sugerencias basadas en el mensaje de error
+     */
+    generateSuggestion(errorMessage) {
+        const message = errorMessage.toLowerCase();
+        if (message.includes('unexpected') && message.includes('identifier')) {
+            return 'Verifica si hay una coma faltante antes del identificador o si la línea anterior no está completa.';
+        }
+        if (message.includes('expected') && message.includes('but found')) {
+            return 'Revisa la sintaxis alrededor de este punto. Puede faltar un carácter específico.';
+        }
+        if (message.includes('missing')) {
+            if (message.includes('semicolon')) {
+                return 'Agrega un punto y coma (;) al final de la declaración.';
+            }
+            if (message.includes('comma')) {
+                return 'Verifica si falta una coma (,) en una lista o declaración.';
+            }
+            if (message.includes('parenthesis')) {
+                return 'Verifica que los paréntesis estén balanceados.';
+            }
+        }
+        if (message.includes('import') || message.includes('export')) {
+            return 'Revisa la sintaxis de import/export. Las líneas pueden estar cortadas o malformadas.';
+        }
+        if (message.includes('const') && message.includes('initializer')) {
+            return 'Las declaraciones const requieren un valor inicial. Ejemplos válidos:\n   • const variable = "valor";\n   • const numero = 42;\n   • const objeto = { propiedad: "valor" };';
+        }
+        return 'Revisa la sintaxis del código alrededor de esta ubicación.';
+    }
+    /**
+     * Combina nuestro contexto de código con el codeframe de oxc-parser
+     */
+    combineWithOxcCodeframe(ourContext, oxcCodeframe) {
+        if (!ourContext) {
+            return oxcCodeframe;
+        }
+        // Si ya tenemos nuestro contexto, podemos agregar el de oxc como referencia adicional
+        const chalkSync = getChalkSync();
+        return (ourContext +
+            '\n' +
+            chalkSync.dim('Codeframe de oxc-parser:') +
+            '\n' +
+            oxcCodeframe);
+    }
+    /**
+     * Formatea un error detallado como texto legible
+     */
+    formatError(error) {
+        let output = '';
+        // Encabezado del error
+        const severity = error.severity.toUpperCase();
+        const chalkSync = getChalkSync();
+        const severityColor = error.severity === 'error'
+            ? chalkSync.red
+            : error.severity === 'warning'
+                ? chalkSync.yellow
+                : chalkSync.blue;
+        if (this.options.colorize) {
+            output +=
+                severityColor(`[${severity}]`) +
+                    ` en ${chalkSync.cyan(error.file)}`;
+        }
+        else {
+            output += `[${severity}] en ${error.file}`;
+        }
+        // Ubicación específica
+        if (error.line) {
+            const location = error.column
+                ? `línea ${error.line}, columna ${error.column}`
+                : `línea ${error.line}`;
+            if (this.options.colorize) {
+                output += ` (${chalkSync.dim(location)})`;
+            }
+            else {
+                output += ` (${location})`;
+            }
+        }
+        output += '\n';
+        // Mensaje de error
+        if (this.options.colorize) {
+            output += `💥 ${chalkSync.bold(error.message)}\n`;
+        }
+        else {
+            output += `💥 ${error.message}\n`;
+        }
+        // Código de error si está disponible
+        if (error.errorCode) {
+            if (this.options.colorize) {
+                output += chalkSync.dim(`   Código: ${error.errorCode}\n`);
+            }
+            else {
+                output += `   Código: ${error.errorCode}\n`;
+            }
+        }
+        // Contexto del código
+        if (error.codeContext) {
+            output += error.codeContext;
+        }
+        // Sugerencia
+        if (error.suggestion) {
+            if (this.options.colorize) {
+                output += `\n💡 ${chalkSync.yellow('Sugerencia:')} ${error.suggestion}\n`;
+            }
+            else {
+                output += `\n💡 Sugerencia: ${error.suggestion}\n`;
+            }
+        }
+        return output;
+    }
+    /**
+     * Analiza múltiples errores de un resultado de parsing
+     */
+    analyzeMultipleErrors(errors, sourceCode, fileName) {
+        return errors.map(error => this.analyzeParsingError(error, sourceCode, fileName));
+    }
+    /**
+     * Formatea múltiples errores como un reporte completo
+     */
+    formatMultipleErrors(errors) {
+        if (errors.length === 0) {
+            return 'No se encontraron errores.';
+        }
+        const chalkSync = getChalkSync();
+        let output = '';
+        if (this.options.colorize) {
+            output += chalkSync.bold.red(`\n🚨 Se encontraron ${errors.length} error(es) de parsing:\n\n`);
+        }
+        else {
+            output += `\n🚨 Se encontraron ${errors.length} error(es) de parsing:\n\n`;
+        }
+        errors.forEach((error, index) => {
+            output += this.formatError(error);
+            // Separador entre errores (excepto el último)
+            if (index < errors.length - 1) {
+                if (this.options.colorize) {
+                    output += chalkSync.dim('─'.repeat(60)) + '\n\n';
+                }
+                else {
+                    output += '─'.repeat(60) + '\n\n';
+                }
+            }
+        });
+        return output;
+    } /**
+     * Genera sugerencias más inteligentes basadas en análisis contextual del error
+     */
+    generateIntelligentSuggestion(errorMessage, sourceCode, line, _column) {
+        const message = errorMessage.toLowerCase();
+        // Análisis contextual del código si tenemos la línea
+        if (line && sourceCode) {
+            const lines = sourceCode.split('\n');
+            const errorLine = lines[line - 1] || '';
+            const prevLine = line > 1 ? lines[line - 2] || '' : '';
+            // Análisis específico para declaraciones const
+            if (message.includes('const') && message.includes('initializer')) {
+                // Detectar el tipo de error específico analizando el contexto
+                if (errorLine
+                    .trim()
+                    .match(/^const\s+[a-zA-Z_][a-zA-Z0-9_]*\s*;/)) {
+                    return ('Declaración const incompleta. Agrega un valor inicial:\n   • const ' +
+                        errorLine.match(/const\s+([a-zA-Z_][a-zA-Z0-9_]*)/)?.[1] +
+                        ' = "valor";\n   • const ' +
+                        errorLine.match(/const\s+([a-zA-Z_][a-zA-Z0-9_]*)/)?.[1] +
+                        ' = 42;\n   • O cambia a "let" si planeas asignar después');
+                }
+                if (errorLine.includes('=') &&
+                    !errorLine.trim().endsWith(';')) {
+                    return 'Parece que la declaración const está incompleta. Verifica:\n   • Que la expresión del lado derecho esté completa\n   • Que termine con punto y coma (;)\n   • Que no falten paréntesis o comillas';
+                }
+                return 'Las declaraciones const requieren un valor inicial:\n   • const variable = "valor";\n   • const numero = 42;\n   • const objeto = { propiedad: "valor" };\n   • const array = [1, 2, 3];';
+            }
+            // Análisis para identificadores inesperados
+            if (message.includes('unexpected') &&
+                message.includes('identifier')) {
+                if (prevLine.trim() &&
+                    !prevLine.trim().endsWith(';') &&
+                    !prevLine.trim().endsWith('{') &&
+                    !prevLine.trim().endsWith('}')) {
+                    return 'La línea anterior parece incompleta. Verifica:\n   • Que termine con punto y coma (;)\n   • Que no falten operadores o comas\n   • Que los paréntesis estén balanceados';
+                }
+                if (errorLine.includes(',') && !errorLine.includes('=')) {
+                    return 'Posible error en declaración de múltiples variables:\n   • const a = 1, b = 2; (para const)\n   • let a, b; a = 1; b = 2; (para let)\n   • Verifica que cada variable tenga su valor asignado';
+                }
+            }
+            // Análisis para import/export malformados
+            if (message.includes('import') || message.includes('export')) {
+                if (errorLine.includes('import') &&
+                    !errorLine.includes('from')) {
+                    return 'Import statement incompleto:\n   • import { item } from "modulo";\n   • import defaultItem from "modulo";\n   • import * as alias from "modulo";';
+                }
+                if (errorLine.includes('export') &&
+                    errorLine.trim().endsWith('export')) {
+                    return 'Export statement incompleto:\n   • export { item };\n   • export default item;\n   • export const item = valor;';
+                }
+            }
+            // Análisis para paréntesis y brackets
+            if (message.includes('expected')) {
+                const openParens = (errorLine.match(/\(/g) || []).length;
+                const closeParens = (errorLine.match(/\)/g) || []).length;
+                const openBrackets = (errorLine.match(/\{/g) || []).length;
+                const closeBrackets = (errorLine.match(/\}/g) || []).length;
+                if (openParens !== closeParens) {
+                    return `Paréntesis desbalanceados (${openParens} abiertos, ${closeParens} cerrados):\n   • Verifica que cada ( tenga su correspondiente )\n   • Revisa llamadas a funciones y expresiones`;
+                }
+                if (openBrackets !== closeBrackets) {
+                    return `Llaves desbalanceadas (${openBrackets} abiertas, ${closeBrackets} cerradas):\n   • Verifica que cada { tenga su correspondiente }\n   • Revisa objetos, funciones y bloques de código`;
+                }
+            }
+        }
+        // Fallback a sugerencias básicas si no hay análisis contextual específico
+        return this.generateSuggestion(errorMessage);
+    }
+}
+/**
+ * Instancia predeterminada del reporter con configuración estándar
+ */
+export const defaultErrorReporter = new ErrorReporter({
+    showLineNumbers: true,
+    showCodeContext: true,
+    contextLines: 2,
+    colorize: true,
+});
+/**
+ * Función helper para analizar y formatear rápidamente un error
+ */
+export function analyzeAndFormatError(error, sourceCode, fileName, options) {
+    const reporter = options
+        ? new ErrorReporter(options)
+        : defaultErrorReporter;
+    const detailedError = reporter.analyzeParsingError(error, sourceCode, fileName);
+    return reporter.formatError(detailedError);
+}
+/**
+ * Función helper para analizar y formatear múltiples errores
+ */
+export function analyzeAndFormatMultipleErrors(errors, sourceCode, fileName, options) {
+    const reporter = options
+        ? new ErrorReporter(options)
+        : defaultErrorReporter;
+    const detailedErrors = reporter.analyzeMultipleErrors(errors, sourceCode, fileName);
+    return reporter.formatMultipleErrors(detailedErrors);
+}
+//# sourceMappingURL=error-reporter.js.map

package/dist/compiler/linter.js

@@ -1 +1,72 @@
-import{env as e}from"node:process";import{logger as t}from"../servicios/logger.js";import{ESLintNode as n}from"./../wrappers/eslint-node.js";import{OxlintNode as r}from"./../wrappers/oxlint-node.js";export async function OxLint(n={}){try{if(!n||!n.bin)return t.warn(`⚠️ Oxlint no se ejecutará: falta la propiedad "bin" en la configuración.`),!1;let i=new r({binPath:n.bin,configFile:n.configFile,fix:n.fix||!1,formats:[`json`],tsconfigPath:e.tsconfigFile||`./tsconfig.json`,...n.oxlintConfig}),a=n.paths||[e.PATH_SOURCE||`./src`];return await i.run(a)}catch(e){throw t.error(`❌ :Error al compilar OxLint:`,e),e}}export async function ESLint(e={}){try{if(!e||!e.bin)return t.warn(`⚠️ ESLint no se ejecutará: falta la propiedad "bin" en la configuración.`),{json:{results:[],errorCount:0,warningCount:0,fixableErrorCount:0,fixableWarningCount:0,fatalErrorCount:0}};let r=new n({binPath:e.bin,configFile:e.configFile,fix:e.fix||!1,extensions:[`.vue`,`.ts`,`.js`],formats:e.format?[e.format]:[`stylish`,`json`],cache:!0,maxWarnings:100,...e.eslintConfig}),i=e.paths||[`src/`];return await r.run(i)}catch(e){throw t.error(`❌ Error al ejecutar ESLint:`,e),e}}
+import { env } from 'node:process';
+import { logger } from '../servicios/logger.js';
+import { ESLintNode, } from './../wrappers/eslint-node.js';
+import { OxlintNode } from './../wrappers/oxlint-node.js';
+export async function OxLint(oxlintConfig = {}) {
+    try {
+        if (!oxlintConfig || !oxlintConfig.bin) {
+            // configFile es opcional si Oxlint lo encuentra por defecto
+            logger.warn('⚠️ Oxlint no se ejecutará: falta la propiedad "bin" en la configuración.');
+            return false; // O un resultado que indique fallo/no ejecución
+        }
+        const oxlintRunner = new OxlintNode({
+            binPath: oxlintConfig.bin, // Usar bin de LinterConfig
+            configFile: oxlintConfig.configFile, // Usar configFile de LinterConfig
+            fix: oxlintConfig.fix || false,
+            formats: ['json'], // Mantener json para parseo consistente si es necesario
+            tsconfigPath: env.tsconfigFile || './tsconfig.json', // Esto es específico de OxlintNode
+            // ... cualquier otra opción específica de oxlintConfig.oxlintConfig
+            ...oxlintConfig.oxlintConfig,
+        });
+        const targetPaths = oxlintConfig.paths || [env.PATH_SOURCE || './src']; // Usar paths de LinterConfig
+        return await oxlintRunner.run(targetPaths);
+    }
+    catch (err) {
+        logger.error('❌ :Error al compilar OxLint:', err);
+        throw err;
+    }
+}
+/**
+ * Ejecuta ESLint en el proyecto con estructura compatible con Oxlint
+ */
+export async function ESLint(config = {}) {
+    try {
+        if (!config || !config.bin) {
+            // configFile es opcional si ESLint lo encuentra por defecto
+            logger.warn('⚠️ ESLint no se ejecutará: falta la propiedad "bin" en la configuración.');
+            // Devolver un ESLintMultiFormatResult vacío o que indique error
+            return {
+                json: {
+                    results: [],
+                    errorCount: 0,
+                    warningCount: 0,
+                    fixableErrorCount: 0,
+                    fixableWarningCount: 0,
+                    fatalErrorCount: 0,
+                },
+            };
+        }
+        // Configuración por defecto para el proyecto
+        const eslintRunner = new ESLintNode({
+            binPath: config.bin, // Usar bin de LinterConfig
+            configFile: config.configFile, // Usar configFile de LinterConfig
+            fix: config.fix || false,
+            // Las siguientes son opciones más específicas de ESLintNode,
+            // podrían moverse a config.eslintConfig si se prefiere mayor anidación.
+            extensions: ['.vue', '.ts', '.js'], // Ejemplo, podría venir de eslintConfig
+            formats: config.format ? [config.format] : ['stylish', 'json'], // Usar format de LinterConfig
+            cache: true, // Ejemplo, podría venir de eslintConfig
+            maxWarnings: 100, // Ejemplo, podría venir de eslintConfig
+            // Sobrescribir o añadir con configuraciones específicas de eslintConfig
+            ...config.eslintConfig,
+        });
+        const targetPaths = config.paths || ['src/']; // Usar paths de LinterConfig
+        const result = await eslintRunner.run(targetPaths);
+        return result;
+    }
+    catch (err) {
+        logger.error('❌ Error al ejecutar ESLint:', err);
+        throw err;
+    }
+}
+//# sourceMappingURL=linter.js.map