versacompiler 2.1.0 → 2.3.0

package/dist/utils/proxyValidator.js

@@ -1 +1,68 @@
-import{get as e}from"node:http";import{get as t}from"node:https";import{URL as n}from"node:url";export async function validateProxyAvailability(r,i=5e3){return new Promise(a=>{try{let o=new n(r),s=o.protocol===`https:`,c=(s?t:e)({hostname:o.hostname,port:o.port||(s?443:80),path:`/`,method:`HEAD`,timeout:i,headers:{"User-Agent":`VersaCompiler-ProxyValidator/1.0`}},e=>{a(!0)});c.on(`error`,()=>{a(!1)}),c.on(`timeout`,()=>{c.destroy(),a(!1)}),c.setTimeout(i),c.end()}catch{a(!1)}})}export function getProxyInfo(e){try{let t=new n(e);return{host:t.hostname,port:t.port||(t.protocol===`https:`?`443`:`80`),protocol:t.protocol.replace(`:`,``)}}catch{return{host:`unknown`,port:`unknown`,protocol:`unknown`}}}
+import { get as httpGet } from 'node:http';
+import { get as httpsGet } from 'node:https';
+import { URL } from 'node:url';
+/**
+ * Valida si un servidor proxy está disponible
+ * @param proxyUrl URL del proxy a validar
+ * @param timeout Timeout en milisegundos (default: 5000)
+ * @returns Promise que resuelve a true si el proxy está disponible
+ */
+export async function validateProxyAvailability(proxyUrl, timeout = 5000) {
+    return new Promise(resolve => {
+        try {
+            const url = new URL(proxyUrl);
+            const isHttps = url.protocol === 'https:';
+            const requestMethod = isHttps ? httpsGet : httpGet;
+            const options = {
+                hostname: url.hostname,
+                port: url.port || (isHttps ? 443 : 80),
+                path: '/',
+                method: 'HEAD',
+                timeout: timeout,
+                headers: {
+                    'User-Agent': 'VersaCompiler-ProxyValidator/1.0',
+                },
+            };
+            const req = requestMethod(options, (_res) => {
+                // Cualquier respuesta HTTP (incluso errores 4xx/5xx) indica que el servidor está arriba
+                resolve(true);
+            });
+            req.on('error', () => {
+                resolve(false);
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                resolve(false);
+            });
+            req.setTimeout(timeout);
+            req.end();
+        }
+        catch {
+            // Error al parsear URL o crear request
+            resolve(false);
+        }
+    });
+}
+/**
+ * Extrae información legible del proxy URL para mostrar al usuario
+ * @param proxyUrl URL del proxy
+ * @returns Objeto con información del proxy
+ */
+export function getProxyInfo(proxyUrl) {
+    try {
+        const url = new URL(proxyUrl);
+        return {
+            host: url.hostname,
+            port: url.port || (url.protocol === 'https:' ? '443' : '80'),
+            protocol: url.protocol.replace(':', ''),
+        };
+    }
+    catch {
+        return {
+            host: 'unknown',
+            port: 'unknown',
+            protocol: 'unknown',
+        };
+    }
+}
+//# sourceMappingURL=proxyValidator.js.map

package/dist/utils/resolve-bin.js

@@ -1 +1,58 @@
-import*as e from"node:path";import*as t from"node:process";import n from"find-root";import r from"fs-extra";function i(t,n){for(let i of n)try{let n=e.join(i,`node_modules`,t);if(r.existsSync(n))return n}catch{}throw Error(`Cannot resolve module ${t} from paths: ${n.join(`, `)}`)}export function resolveBin(a,{executable:o=a,paths:s=[t.cwd()]}={}){let c;try{c=n(i(a,s))}catch{let n=s[0]||t.cwd(),i=e.join(n,`node_modules`,a,`package.json`);if(r.existsSync(i))c=e.dirname(i);else throw Error(`Cannot resolve module ${a}`)}let l=e.join(c,`package.json`),u=r.readJsonSync(l);if(!u.bin)throw Error(`no bin found in ${u.name}@${u.version} in path ${l}`);let d=typeof u.bin==`string`?u.bin:u.bin[o];return e.join(c,d)}
+import * as path from 'node:path';
+import * as process from 'node:process';
+import * as fs from 'fs-extra';
+// Reimplementación simple de findRoot para evitar dependencias problemáticas
+function findRoot(start) {
+    let current = start;
+    while (current !== path.dirname(current)) {
+        if (fs.existsSync(path.join(current, 'package.json'))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    throw new Error(`Cannot find package.json from ${start}`);
+}
+// Función helper para resolver módulos sin createRequire
+function resolveModule(moduleName, paths) {
+    for (const searchPath of paths) {
+        try {
+            const nodeModulesPath = path.join(searchPath, 'node_modules', moduleName);
+            if (fs.existsSync(nodeModulesPath)) {
+                return nodeModulesPath;
+            }
+        }
+        catch {
+            // Continuar con el siguiente path
+        }
+    }
+    throw new Error(`Cannot resolve module ${moduleName} from paths: ${paths.join(', ')}`);
+}
+export function resolveBin(moduleName, { executable = moduleName, paths = [process.cwd()], } = {}) {
+    let rootDir;
+    try {
+        const resolved = resolveModule(moduleName, paths);
+        rootDir = findRoot(resolved);
+    }
+    catch {
+        // Intentar resolver package.json directamente
+        const basePath = paths[0] || process.cwd();
+        const packagePath = path.join(basePath, 'node_modules', moduleName, 'package.json');
+        if (fs.existsSync(packagePath)) {
+            rootDir = path.dirname(packagePath);
+        }
+        else {
+            throw new Error(`Cannot resolve module ${moduleName}`);
+        }
+    }
+    const packageJsonPath = path.join(rootDir, 'package.json');
+    const packageJson = fs.readJsonSync(packageJsonPath);
+    if (!packageJson.bin) {
+        throw new Error(`no bin found in ${packageJson.name}@${packageJson.version} in path ${packageJsonPath}`);
+    }
+    const binProp = typeof packageJson.bin === 'string'
+        ? packageJson.bin
+        : packageJson.bin[executable];
+    const binPath = path.join(rootDir, binProp);
+    return binPath;
+}
+//# sourceMappingURL=resolve-bin.js.map

package/dist/utils/utils.js

@@ -1 +1,21 @@
-export const showTimingForHumans=e=>e<1e3?`${e} ms`:e<6e4?`${e/1e3} s`:e<36e5?`${e/6e4} min`:`${e/36e5} h`;
+/**
+ * Converts a 24-hour time string to a 12-hour time string with AM/PM.
+ *
+ * @param {number} timing - The value of the timing en miliseconds.
+ * @returns {string} the timing in ms, seconds, minutes or hours.
+ */
+export const showTimingForHumans = (timing) => {
+    if (timing < 1000) {
+        return `${timing} ms`;
+    }
+    else if (timing < 60000) {
+        return `${timing / 1000} s`;
+    }
+    else if (timing < 3600000) {
+        return `${timing / 60000} min`;
+    }
+    else {
+        return `${timing / 3600000} h`;
+    }
+};
+//# sourceMappingURL=utils.js.map