versacompiler 1.0.4 → 2.0.0

package/dist/wrappers/eslint-node.js

@@ -0,0 +1,145 @@
+import path from 'node:path'; // Añadir importación de path
+import { cwd } from 'node:process'; // Añadir importación de cwd
+import { execa } from 'execa';
+import { resolveBin } from '../utils/resolve-bin.js';
+export class ESLintNode {
+    binPath;
+    fix;
+    configFile;
+    quiet;
+    deny;
+    allow;
+    noIgnore;
+    ignorePath;
+    ignorePattern;
+    formats;
+    additionalArgs;
+    constructor(options = {}) {
+        this.binPath = options.binPath || ESLintNode.getDefaultBinPath();
+        this.fix = options.fix || false;
+        this.configFile = options.configFile;
+        this.quiet = options.quiet || false;
+        this.deny = options.deny;
+        this.allow = options.allow;
+        this.noIgnore = options.noIgnore || false;
+        this.ignorePath = options.ignorePath;
+        this.ignorePattern = options.ignorePattern;
+        this.formats = options.formats || ['json']; // Por defecto, solo 'json'
+        this.additionalArgs = options.additionalArgs;
+    }
+    static getDefaultBinPath() {
+        try {
+            return resolveBin('eslint', { executable: 'eslint' });
+        }
+        catch (error) {
+            console.error("Error al resolver el binario de ESLint. Asegúrate de que 'eslint' esté instalado y en el PATH, o provee la opción 'binPath'.", error);
+            throw new Error('Error al resolver el binario de ESLint.');
+        }
+    }
+    async version() {
+        const { stdout: version } = await execa(this.binPath, ['--version']);
+        return version;
+    }
+    /**
+     * Ejecuta ESLint para los formatos configurados y devuelve los resultados.
+     * @param paths Rutas o patrones glob para los archivos a lint.
+     * @returns Un objeto donde cada clave es un formato y el valor es el resultado (parseado si es JSON).
+     */
+    async run(paths = []) {
+        const results = {};
+        const targetPaths = paths.length > 0 ? paths : ['.'];
+        const projectRoot = cwd(); // Obtener la ruta raíz del proyecto
+        await Promise.all(this.formats.map(async (format) => {
+            const cliArgs = this.toCliArgs(format, targetPaths);
+            try {
+                const { stdout, stderr, exitCode } = await execa(this.binPath, cliArgs, { reject: false });
+                if (exitCode !== 0 &&
+                    format !== 'json' &&
+                    format !== 'sarif') {
+                    if (stderr && !stdout) {
+                        console.warn(`ESLint para formato '${format}' finalizó con código ${exitCode} y stderr: ${stderr}`);
+                    }
+                }
+                if (format === 'json') {
+                    // ESLint devuelve un array de archivos con mensajes anidados
+                    // Necesitamos aplanar esta estructura para que coincida con lo que espera el compilador
+                    const eslintOutput = JSON.parse(stdout || '[]');
+                    const flattenedResults = [];
+                    for (const fileResult of eslintOutput) {
+                        for (const message of fileResult.messages || []) {
+                            // Calcular ruta relativa
+                            const relativeFilePath = path
+                                .relative(projectRoot, fileResult.filePath)
+                                .replace(/\\/g, '/');
+                            flattenedResults.push({
+                                filePath: relativeFilePath, // Usar ruta relativa
+                                file: relativeFilePath, // Alias para compatibilidad
+                                message: message.message,
+                                severity: message.severity,
+                                ruleId: message.ruleId,
+                                line: message.line,
+                                column: message.column,
+                            });
+                        }
+                    }
+                    results[format] = flattenedResults;
+                }
+                else if (format === 'sarif') {
+                    results[format] = JSON.parse(stdout || '{}');
+                }
+                else {
+                    results[format] = stdout;
+                }
+            }
+            catch (error) {
+                console.error(`Error ejecutando ESLint para formato '${format}':`, error.shortMessage || error.message);
+                results[format] = {
+                    error: error.shortMessage || error.message,
+                    details: error,
+                };
+            }
+        }));
+        return results;
+    }
+    /**
+     * Construye el array de argumentos para pasar al CLI de ESLint para un formato específico.
+     */
+    toCliArgs(format, paths) {
+        const args = [];
+        // Opciones directas
+        if (this.fix)
+            args.push('--fix');
+        if (this.configFile)
+            args.push('--config', this.configFile);
+        if (this.quiet)
+            args.push('--quiet');
+        if (this.noIgnore)
+            args.push('--no-ignore');
+        if (this.ignorePath)
+            args.push('--ignore-path', this.ignorePath);
+        if (this.deny)
+            this.deny.forEach(rule => args.push('--rule', `${rule}:error`));
+        if (this.allow)
+            this.allow.forEach(rule => args.push('--rule', `${rule}:off`));
+        if (this.ignorePattern)
+            this.ignorePattern.forEach(pattern => args.push('--ignore-pattern', pattern));
+        // Formato
+        if (format !== 'stylish') {
+            args.push('--format', format);
+        }
+        // Argumentos adicionales
+        if (this.additionalArgs)
+            args.push(...this.additionalArgs);
+        // Rutas/patrones
+        args.push(...paths);
+        return args;
+    }
+    /**
+     * Método estático para crear una instancia de ESLintNode, similar al código de referencia.
+     * @param options Opciones de configuración.
+     */
+    static create(options) {
+        return new ESLintNode(options);
+    }
+}
+//# sourceMappingURL=eslint-node.js.map

package/dist/wrappers/oxlint-node.js

@@ -0,0 +1,120 @@
+import { execa } from 'execa';
+import { resolveBin } from '../utils/resolve-bin.js';
+export class OxlintNode {
+    binPath;
+    fix;
+    configFile;
+    tsconfigPath;
+    quiet;
+    deny;
+    allow;
+    noIgnore;
+    ignorePath;
+    ignorePattern;
+    formats;
+    additionalArgs;
+    constructor(options = {}) {
+        this.binPath = options.binPath || OxlintNode.getDefaultBinPath();
+        this.fix = options.fix || false;
+        this.configFile = options.configFile;
+        this.tsconfigPath = options.tsconfigPath;
+        this.quiet = options.quiet || false;
+        this.deny = options.deny;
+        this.allow = options.allow;
+        this.noIgnore = options.noIgnore || false;
+        this.ignorePath = options.ignorePath;
+        this.ignorePattern = options.ignorePattern;
+        this.formats = options.formats || ['json']; // Por defecto, solo 'json'
+        this.additionalArgs = options.additionalArgs;
+    }
+    static getDefaultBinPath() {
+        try {
+            return resolveBin('oxlint', { executable: 'oxlint' });
+        }
+        catch (error) {
+            console.error("Error al resolver el binario de Oxlint. Asegúrate de que 'oxlint' esté instalado y en el PATH, o provee la opción 'binPath'.", error);
+            throw new Error('Error al resolver el binario de Oxlint.');
+        }
+    }
+    async version() {
+        const { stdout: version } = await execa(this.binPath, ['--version']);
+        return version;
+    }
+    /**
+     * Ejecuta Oxlint para los formatos configurados y devuelve los resultados.
+     * @param paths Rutas o patrones glob para los archivos a lint.
+     * @returns Un objeto donde cada clave es un formato y el valor es el resultado (parseado si es JSON).
+     */
+    async run(paths = []) {
+        const results = {};
+        const targetPaths = paths.length > 0 ? paths : ['.'];
+        await Promise.all(this.formats.map(async (format) => {
+            const cliArgs = this.toCliArgs(format, targetPaths);
+            try {
+                const { stdout, stderr, exitCode } = await execa(this.binPath, cliArgs, { reject: false });
+                if (exitCode !== 0 &&
+                    format !== 'json' &&
+                    format !== 'sarif') {
+                    if (stderr && !stdout) {
+                        console.warn(`Oxlint para formato '${format}' finalizó con código ${exitCode} y stderr: ${stderr}`);
+                    }
+                }
+                results[format] =
+                    format === 'json' || format === 'sarif'
+                        ? JSON.parse(stdout || '{}')
+                        : stdout;
+            }
+            catch (error) {
+                console.error(`Error ejecutando Oxlint para formato '${format}':`, error.shortMessage || error.message);
+                results[format] = {
+                    error: error.shortMessage || error.message,
+                    details: error,
+                };
+            }
+        }));
+        return results;
+    }
+    /**
+     * Construye el array de argumentos para pasar al CLI de Oxlint para un formato específico.
+     */
+    toCliArgs(format, paths) {
+        const args = [];
+        // Opciones directas
+        if (this.fix)
+            args.push('--fix');
+        if (this.configFile)
+            args.push('--config', this.configFile);
+        if (this.tsconfigPath)
+            args.push('--tsconfig', this.tsconfigPath); // Añadido
+        if (this.quiet)
+            args.push('--quiet');
+        if (this.noIgnore)
+            args.push('--no-ignore');
+        if (this.ignorePath)
+            args.push('--ignore-path', this.ignorePath);
+        if (this.deny)
+            this.deny.forEach(rule => args.push('--deny', rule));
+        if (this.allow)
+            this.allow.forEach(rule => args.push('--allow', rule));
+        if (this.ignorePattern)
+            this.ignorePattern.forEach(pattern => args.push('--ignore-pattern', pattern));
+        // Formato
+        if (format !== 'default') {
+            args.push('--format', format);
+        }
+        // Argumentos adicionales
+        if (this.additionalArgs)
+            args.push(...this.additionalArgs);
+        // Rutas/patrones
+        args.push(...paths);
+        return args;
+    }
+    /**
+     * Método estático para crear una instancia de OxlintNode, similar al código de referencia.
+     * @param options Opciones de configuración.
+     */
+    static create(options) {
+        return new OxlintNode(options);
+    }
+}
+//# sourceMappingURL=oxlint-node.js.map

package/dist/wrappers/tailwind-node.js

@@ -0,0 +1,92 @@
+import { execa } from 'execa';
+import { resolveBin } from '../utils/resolve-bin.js';
+export class TailwindNode {
+    binPath;
+    input;
+    output;
+    content;
+    minify;
+    additionalArgs;
+    configFile;
+    /**
+     * Crea una instancia de TailwindNode.
+     * @param options Opciones para la compilación.
+     */
+    constructor(options) {
+        if (!options.input) {
+            throw new Error('La opción "input" es requerida.');
+        }
+        if (!options.output) {
+            throw new Error('La opción "output" es requerida.');
+        }
+        this.binPath = options.binPath || TailwindNode.getDefaultBinPath();
+        this.input = options.input;
+        this.output = options.output;
+        this.content = options.content;
+        this.minify = options.minify || false;
+        this.additionalArgs = options.additionalArgs;
+        this.configFile = options.configFile;
+    }
+    /**
+     * Intenta resolver la ruta al ejecutable de Tailwind CSS.
+     */
+    static getDefaultBinPath() {
+        try {
+            return resolveBin('tailwindcss', {
+                executable: 'tailwindcss',
+            });
+        }
+        catch (error) {
+            console.error("Error al resolver el binario de Tailwind CSS. Asegúrate de que esté instalado y en el PATH, o provee la opción 'binPath'.", error);
+            throw new Error('Error al resolver el binario de Tailwind CSS.');
+        }
+    }
+    /**
+     * Ejecuta el proceso de compilación de Tailwind CSS.
+     * @returns Una promesa que resuelve con el resultado de la compilación.
+     */
+    async run() {
+        const cliArgs = this.toCliArgs();
+        try {
+            const result = await execa(this.binPath, cliArgs);
+            return {
+                success: true,
+                message: `Tailwind CSS compilado exitosamente desde ${this.input} a ${this.output}`,
+                details: result,
+            };
+        }
+        catch (error) {
+            const execaError = error; // error de execa
+            console.error(`Error en la compilación de Tailwind CSS: ${execaError.message}`);
+            if (execaError.stderr) {
+                console.error(`Stderr: ${execaError.stderr}`);
+            }
+            return {
+                success: false,
+                message: `Error en la compilación de Tailwind CSS: ${execaError.shortMessage || execaError.message}`,
+                details: execaError,
+            };
+        }
+    }
+    /**
+     * Construye el array de argumentos para pasar al CLI de Tailwind CSS.
+     */
+    toCliArgs() {
+        const args = ['-i', this.input, '-o', this.output];
+        if (this.configFile) {
+            args.push('--config', this.configFile);
+        }
+        if (this.content && this.content.length > 0) {
+            args.push('--content');
+            args.push(...this.content);
+        }
+        if (this.minify) {
+            args.push('--minify');
+        }
+        if (this.additionalArgs && this.additionalArgs.length > 0) {
+            args.push(...this.additionalArgs);
+        }
+        return args;
+    }
+}
+//# sourceMappingURL=tailwind-node.js.map

package/package.json

@@ -1,10 +1,10 @@
 {
     "name": "versacompiler",
-    "version": "1.0.4",
+    "version": "2.0.0",
     "description": "Una herramienta para compilar y minificar archivos .vue, .js y .ts para proyectos de Vue 3 con soporte para TypeScript.",
-    "main": "dist/index.js",
+    "main": "dist/main.js",
     "bin": {
-        "versacompiler": "dist/index.js"
+        "versacompiler": "dist/main.js"
     },
     "publishConfig": {
         "access": "public"
@@ -16,10 +16,17 @@
     ],
     "type": "module",
     "scripts": {
-        "dev": "node --watch dist/index.js",
-        "compile": "node dist/index.js",
-        "compile-dev": "node dist/index.js --all",
-        "compile-prod": "node dist/index.js --all --prod"
+        "dev": "tsx --watch src/main.ts --watch --verbose --tailwind",
+        "compile": "tsx src/main.ts --all",
+        "test": "jest --config jest.config.js",
+        "build": "tsx src/main.ts --all -t --clean -y",
+        "lint": "oxlint --fix --config .oxlintrc.json",
+        "lint:eslint": "eslint --ext .js,.ts,.vue src/ --fix",
+        "perf": "scripts\\run-performance.bat",
+        "perf:test": "jest tests/performance.test.ts --config jest.config.js --testTimeout=300000",
+        "perf:report": "node scripts/generate-performance-report.js",
+        "perf:open": "start performance-results/dashboard.html",
+        "perf:clean": "rmdir /s /q performance-results 2>nul || echo 'Performance results cleaned'"
     },
     "keywords": [
         "vue",
@@ -27,26 +34,66 @@
         "minifier",
         "vue3",
         "versacompiler",
-        "typescript"
+        "typescript",
+        "linter"
     ],
     "author": "Jorge Jara H (kriollone@gmail.com)",
     "license": "MIT",
     "dependencies": {
-        "acorn": "^8.14.1",
+        "@vue/compiler-dom": "^3.5.16",
+        "@vue/reactivity": "^3.5.16",
+        "@vue/runtime-core": "^3.5.16",
+        "@vue/runtime-dom": "^3.5.16",
         "browser-sync": "^3.0.4",
         "chalk": "5.4.1",
         "chokidar": "^4.0.3",
+        "enhanced-resolve": "^5.18.1",
+        "execa": "^9.6.0",
+        "find-root": "^1.1.0",
+        "fs-extra": "^11.3.0",
         "get-port": "^7.1.0",
-        "oxc-minify": "^0.69.0",
+        "oxc-minify": "^0.72.3",
+        "oxc-parser": "^0.72.3",
+        "oxc-transform": "^0.72.3",
+        "resolve": "^1.22.10",
+        "tsx": "^4.19.4",
         "typescript": "^5.8.3",
-        "vue": "3.5.13"
+        "vue": "3.5.16",
+        "yargs": "^18.0.0"
     },
     "devDependencies": {
-        "@tailwindcss/cli": "^4.1.6",
-        "@types/node": "^22.15.17",
+        "@eslint/eslintrc": "^3.3.1",
+        "@tailwindcss/cli": "^4.1.8",
+        "@types/browser-sync": "^2.29.0",
+        "@types/find-root": "^1.1.4",
+        "@types/fs-extra": "^11.0.4",
+        "@types/jest": "^29.5.14",
+        "@types/mocha": "^10.0.10",
+        "@types/node": "^22.15.30",
+        "@types/resolve": "^1.20.6",
+        "@types/yargs": "^17.0.33",
+        "@typescript-eslint/eslint-plugin": "^8.34.0",
+        "@typescript-eslint/parser": "^8.34.0",
+        "@vue/eslint-config-typescript": "^14.5.0",
+        "@vue/test-utils": "^2.4.6",
         "code-tag": "^1.2.0",
-        "oxlint": "^0.16.10",
+        "eslint": "^9.28.0",
+        "eslint-import-resolver-typescript": "^4.4.3",
+        "eslint-plugin-import": "^2.31.0",
+        "eslint-plugin-oxlint": "^0.17.0",
+        "eslint-plugin-promise": "^7.2.1",
+        "eslint-plugin-unicorn": "^59.0.1",
+        "eslint-plugin-vue": "^10.2.0",
+        "happy-dom": "^17.6.3",
+        "jest": "^29.7.0",
+        "jest-environment-jsdom": "30.0.0-beta.3",
+        "jest-environment-node": "30.0.0-beta.3",
+        "oxlint": "^0.17.0",
         "prettier": "3.5.3",
-        "tailwindcss": "^4.1.6"
+        "rimraf": "^6.0.1",
+        "sweetalert2": "^11.22.0",
+        "tailwindcss": "^4.1.8",
+        "ts-jest": "^29.3.4",
+        "vue-eslint-parser": "^10.1.3"
     }
 }