vanilla-builder 0.1.0 → 0.3.0

package/src/jsinfo.js

@@ -1,6 +1,7 @@
 // Análisis estático de JavaScript con acorn: nivel de sintaxis, globales, workers y rutas.
 import * as acorn from 'acorn';
 import * as walk from 'acorn-walk';
+import { L } from './i18n.js';
 
 const VERSIONS = [5, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026];
 const LATEST = 'latest';
@@ -124,7 +125,6 @@ export function analyzeJs(code, opts = {}) {
   const info = {
     ok: true,
     isModule,
-    level: detectLevel(code, sourceType),
     strict,
     top: isModule ? new Map() : globalBindings(ast, strict),
     imports: [],
@@ -139,6 +139,12 @@ export function analyzeJs(code, opts = {}) {
     hasImportMeta: false,
     hasModuleSyntax: false,
   };
+  // El nivel ES cuesta varios parseos: solo se calcula si alguien lo pide (la mayoría de análisis no lo necesitan).
+  let level;
+  Object.defineProperty(info, 'level', {
+    enumerable: true,
+    get: () => (level === undefined ? (level = detectLevel(code, sourceType)) : level),
+  });
   const addWorker = (arg, kind, optsNode) => {
     if (!arg) return;
     let spec = null;
@@ -244,20 +250,89 @@ export function checkSyntax(code, isModule) {
   }
 }
 
+// Nombres que esbuild crea al adaptar sintaxis a navegadores antiguos: temporales (_a, _b2) y ayudantes (__async).
+const ESBUILD_TEMP = /^(_[a-z]\d*|__[A-Za-z]+\d*)$/;
+
+/**
+ * Al transpilar un script clásico, esbuild puede declarar temporales en el ámbito global (var _a).
+ * Si TODAS las globales nuevas son de ese tipo, se renombran en todo el archivo a `${prefix}nombre`
+ * (único por archivo), así no pueden chocar con otros scripts. Devuelve el código nuevo, o null si no aplica.
+ * El renombrado es consistente en todos los ámbitos, así que no cambia el significado del código.
+ */
+export function isolateTempGlobals(code, before, prefix) {
+  let ast;
+  try {
+    ast = parse(code, 'script', LATEST);
+  } catch {
+    return null;
+  }
+  const top = globalBindings(
+    ast,
+    ast.body.some((s) => s.directive === 'use strict'),
+  );
+  const fresh = [...top.keys()].filter((n) => !before.has(n));
+  if (!fresh.length || !fresh.every((n) => ESBUILD_TEMP.test(n))) return null;
+  const rename = new Map(fresh.map((n) => [n, `${prefix}${n}`]));
+  const edits = new Map();
+  walk.fullAncestor(ast, (node, _state, ancestors) => {
+    if (node.type !== 'Identifier' || !rename.has(node.name)) return;
+    const p = ancestors[ancestors.length - 2];
+    const to = rename.get(node.name);
+    if (p) {
+      if (p.type === 'MemberExpression' && p.property === node && !p.computed) return;
+      if (p.type === 'Property' && p.shorthand) {
+        // { _a } → { _a: nuevo }: la clave se conserva, el valor se renombra.
+        edits.set(node.start, { start: node.start, end: node.end, text: `${node.name}: ${to}` });
+        return;
+      }
+      if ((p.type === 'Property' || p.type === 'MethodDefinition' || p.type === 'PropertyDefinition') && p.key === node && !p.computed) return;
+      if (p.type === 'LabeledStatement' || p.type === 'BreakStatement' || p.type === 'ContinueStatement') return;
+    }
+    if (!edits.has(node.start)) edits.set(node.start, { start: node.start, end: node.end, text: to });
+  });
+  let out = code;
+  for (const e of [...edits.values()].sort((a, b) => b.start - a.start)) out = out.slice(0, e.start) + e.text + out.slice(e.end);
+  return out;
+}
+
 /**
  * Compara las globales de un script antes y después de transformarlo.
  * `allowPrefix` permite nombres nuevos con ese prefijo (los que añade el ofuscador).
  */
 export function compareGlobals(before, afterCode, allowPrefix = null) {
-  const after = analyzeJs(afterCode, { module: false });
-  if (!after.ok) return { ok: false, reason: `el resultado no es JS válido (${after.error})` };
+  // Solo hacen falta las globales: un parseo y un recorrido, sin el análisis completo.
+  let ast;
+  try {
+    ast = parse(afterCode, 'script', LATEST);
+  } catch (err) {
+    return { ok: false, reason: L(`el resultado no es JS válido (${err.message})`, `the result is not valid JS (${err.message})`) };
+  }
+  const after = {
+    top: globalBindings(
+      ast,
+      ast.body.some((s) => s.directive === 'use strict'),
+    ),
+  };
   for (const [name, kind] of before) {
-    if (!after.top.has(name)) return { ok: false, reason: `desaparece la global "${name}"` };
-    if (after.top.get(name) !== kind) return { ok: false, reason: `la global "${name}" cambia de tipo (${kind} → ${after.top.get(name)})` };
+    if (!after.top.has(name)) return { ok: false, reason: L(`desaparece la global "${name}"`, `the global "${name}" disappears`) };
+    if (after.top.get(name) !== kind)
+      return {
+        ok: false,
+        reason: L(
+          `la global "${name}" cambia de tipo (${kind} → ${after.top.get(name)})`,
+          `the global "${name}" changes kind (${kind} → ${after.top.get(name)})`,
+        ),
+      };
   }
   for (const name of after.top.keys()) {
     if (!before.has(name) && !(allowPrefix && name.startsWith(allowPrefix)))
-      return { ok: false, reason: `aparece una global nueva "${name}" que podría chocar con otros scripts` };
+      return {
+        ok: false,
+        reason: L(
+          `aparece una global nueva "${name}" que podría chocar con otros scripts`,
+          `a new global "${name}" appears that could clash with other scripts`,
+        ),
+      };
   }
   return { ok: true };
 }

package/src/obfuscate.js

@@ -3,6 +3,7 @@ import * as acorn from 'acorn';
 import { shortHash } from './util.js';
 import { compareGlobals, moduleShape, checkSyntax } from './jsinfo.js';
 import { importOptional } from './optional.js';
+import { L } from './i18n.js';
 
 // Nunca se activan solos: cambian el comportamiento o rompen código que comparte globales.
 const FORCED_SAFE = { renameGlobals: false, renameProperties: false, sourceMap: false, target: 'browser' };
@@ -101,7 +102,7 @@ let engine = null;
 /** Carga javascript-obfuscator (instalado junto a Builder o en el proyecto). */
 export async function ensureObfuscator(projectRoot) {
   if (!engine) {
-    const mod = await importOptional('javascript-obfuscator', projectRoot, 'para ofuscar el JavaScript');
+    const mod = await importOptional('javascript-obfuscator', projectRoot, L('para ofuscar el JavaScript', 'to obfuscate JavaScript'));
     engine = mod.default ?? mod;
   }
   return engine;
@@ -143,15 +144,18 @@ export function obfuscateSafe(code, { isModule, options, id, globals }) {
   try {
     out = engine.obfuscate(body, opts).getObfuscatedCode();
   } catch (err) {
-    return { code: null, reason: `el ofuscador falló (${String(err.message).split('\n')[0]})` };
+    return {
+      code: null,
+      reason: L(`el ofuscador falló (${String(err.message).split('\n')[0]})`, `the obfuscator failed (${String(err.message).split('\n')[0]})`),
+    };
   }
   if (isModule) {
     const err = checkSyntax(out, true);
-    if (err) return { code: null, reason: `resultado inválido (${err})` };
+    if (err) return { code: null, reason: L(`resultado inválido (${err})`, `invalid result (${err})`) };
     const a = moduleShape(body);
     const b = moduleShape(out);
     if (!a || !b || a.exports !== b.exports || a.imports !== b.imports)
-      return { code: null, reason: 'cambiaron las exportaciones o importaciones del módulo' };
+      return { code: null, reason: L('cambiaron las exportaciones o importaciones del módulo', 'the module exports or imports changed') };
   } else {
     const cmp = compareGlobals(globals, out, prefix);
     if (!cmp.ok) return { code: null, reason: cmp.reason };

package/src/optional.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { BuildError } from './util.js';
+import { L } from './i18n.js';
 
 const cache = new Map();
 
@@ -25,9 +26,12 @@ export async function importOptional(name, projectRoot, purpose) {
     }
   }
   if (!mod)
-    throw new BuildError(`Falta el paquete opcional "${name}" ${purpose}.`, [
-      `Instálalo una vez con:  npm install --save-dev ${name}`,
-      'Builder lo carga solo cuando hace falta, por eso no viene incluido (así la instalación base es ligera).',
+    throw new BuildError(L(`Falta el paquete opcional "${name}" ${purpose}.`, `Missing optional package "${name}" ${purpose}.`), [
+      L(`Instálalo una vez con:  npm install --save-dev ${name}`, `Install it once with:  npm install --save-dev ${name}`),
+      L(
+        'Builder lo carga solo cuando hace falta, por eso no viene incluido (así la instalación base es ligera).',
+        'Builder loads it only when needed, so it is not bundled (this keeps the base install small).',
+      ),
     ]);
   cache.set(name, mod);
   return mod;

package/src/output.js

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { BuildError, isInside, retryFs, copyDir } from './util.js';
+import { L } from './i18n.js';
 
 export const MANIFEST = '.builder-manifest.json';
 
@@ -12,18 +13,40 @@ export function assertSafeOutDir(cfg, { force = false } = {}) {
   const root = path.resolve(cfg.root);
   const parsed = path.parse(out);
   const same = (a, b) => path.relative(a, b) === '';
-  if (same(out, root)) throw new BuildError('"outDir" no puede ser la propia carpeta del proyecto: se borraría el código fuente.');
-  if (isInside(out, root)) throw new BuildError(`"outDir" (${out}) contiene al proyecto; se borraría el código fuente.`);
-  if (same(out, parsed.root)) throw new BuildError('"outDir" no puede ser la raíz de una unidad.');
-  if (same(out, os.homedir())) throw new BuildError('"outDir" no puede ser tu carpeta de usuario.');
+  if (same(out, root))
+    throw new BuildError(
+      L(
+        '"outDir" no puede ser la propia carpeta del proyecto: se borraría el código fuente.',
+        '"outDir" cannot be the project folder itself: the source code would be deleted.',
+      ),
+    );
+  if (isInside(out, root))
+    throw new BuildError(
+      L(
+        `"outDir" (${out}) contiene al proyecto; se borraría el código fuente.`,
+        `"outDir" (${out}) contains the project; the source code would be deleted.`,
+      ),
+    );
+  if (same(out, parsed.root)) throw new BuildError(L('"outDir" no puede ser la raíz de una unidad.', '"outDir" cannot be the root of a drive.'));
+  if (same(out, os.homedir())) throw new BuildError(L('"outDir" no puede ser tu carpeta de usuario.', '"outDir" cannot be your home folder.'));
   if (!cfg.clean || force) return;
   if (fs.existsSync(out)) {
-    if (!fs.statSync(out).isDirectory()) throw new BuildError(`"outDir" existe y no es una carpeta: ${out}`);
+    if (!fs.statSync(out).isDirectory())
+      throw new BuildError(L(`"outDir" existe y no es una carpeta: ${out}`, `"outDir" exists and is not a folder: ${out}`));
     const entries = fs.readdirSync(out);
     if (entries.length && !entries.includes(MANIFEST))
-      throw new BuildError(`La carpeta de salida ${out} ya tiene archivos y no la creó Builder. No la borro para no perder datos.`, [
-        'Elige otra carpeta con --out, vacíala tú mismo o usa --force si estás seguro.',
-      ]);
+      throw new BuildError(
+        L(
+          `La carpeta de salida ${out} ya tiene archivos y no la creó Builder. No la borro para no perder datos.`,
+          `The output folder ${out} already has files and was not created by Builder. Not deleting it, to avoid losing data.`,
+        ),
+        [
+          L(
+            'Elige otra carpeta con --out, vacíala tú mismo o usa --force si estás seguro.',
+            'Choose another folder with --out, empty it yourself, or use --force if you are sure.',
+          ),
+        ],
+      );
   }
 }
 
@@ -89,7 +112,12 @@ export async function swapIntoPlace(cfg, staging) {
       await rmrf(staging);
     } catch (copyErr) {
       if (exists) await retryFs(() => fs.promises.rename(old, out)).catch(() => {});
-      throw new BuildError(`No pude colocar la salida en ${out}: ${copyErr.message ?? err.message}`);
+      throw new BuildError(
+        L(
+          `No pude colocar la salida en ${out}: ${copyErr.message ?? err.message}`,
+          `Could not place the output in ${out}: ${copyErr.message ?? err.message}`,
+        ),
+      );
     }
   }
   if (exists) await rmrf(old).catch(() => {});

package/src/plugins.js

@@ -0,0 +1,126 @@
+// Plugins: ganchos sencillos para casos que Builder no cubre.
+//
+//   export default {
+//     plugins: [
+//       {
+//         name: 'version',
+//         filter: /\.(html|js)$/,                                  // opcional: a qué archivos se aplica transform
+//         transform: ({ path, code }) => code.replaceAll('__VERSION__', '1.2.3'),
+//         buildStart: ({ config, mode }) => {},
+//         buildEnd: ({ result, outDir }) => {},
+//       },
+//     ],
+//   };
+//
+// En builder.config.json se nombran paquetes: "plugins": ["mi-plugin", ["otro-plugin", { "opcion": 1 }]].
+// Un paquete exporta el objeto plugin o una función (opciones) => plugin.
+//
+// transform cambia el CÓDIGO FUENTE (HTML, CSS, JS, TS) antes de procesarlo: así el hash, el SRI
+// y la verificación final se calculan sobre el resultado del plugin.
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { BuildError } from './util.js';
+import { L } from './i18n.js';
+
+export const TRANSFORM_EXT = new Set(['.html', '.htm', '.css', '.js', '.mjs', '.cjs', '.ts', '.mts', '.cts']);
+const HOOKS = ['transform', 'buildStart', 'buildEnd'];
+
+/** Errores de validación de la opción "plugins" (antes de cargar paquetes). */
+export function validatePlugins(list) {
+  if (!Array.isArray(list)) return [L('"plugins" debe ser una lista.', '"plugins" must be a list.')];
+  const errors = [];
+  list.forEach((p, i) => {
+    const ok =
+      typeof p === 'string' ||
+      (Array.isArray(p) && typeof p[0] === 'string' && p.length <= 2) ||
+      (p && typeof p === 'object' && !Array.isArray(p) && typeof p.name === 'string');
+    if (!ok)
+      errors.push(
+        L(
+          `"plugins[${i}]" debe ser un nombre de paquete, [nombre, opciones] o un objeto con "name".`,
+          `"plugins[${i}]" must be a package name, [name, options] or an object with "name".`,
+        ),
+      );
+    else if (p && typeof p === 'object' && !Array.isArray(p)) {
+      for (const k of Object.keys(p))
+        if (!['name', 'filter', ...HOOKS].includes(k))
+          errors.push(
+            L(
+              `"plugins[${i}].${k}" no es un gancho conocido (${HOOKS.join(', ')}).`,
+              `"plugins[${i}].${k}" is not a known hook (${HOOKS.join(', ')}).`,
+            ),
+          );
+    }
+  });
+  return errors;
+}
+
+/** Carga los plugins nombrados como paquete (desde el proyecto) y devuelve objetos plugin. */
+export async function loadPlugins(list, root) {
+  const out = [];
+  for (const entry of list) {
+    if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
+      out.push(entry);
+      continue;
+    }
+    const [name, options] = Array.isArray(entry) ? entry : [entry, undefined];
+    let mod;
+    try {
+      const req = createRequire(path.join(root, 'package.json'));
+      mod = await import(pathToFileURL(req.resolve(name)).href);
+    } catch (err) {
+      throw new BuildError(L(`No se pudo cargar el plugin "${name}": ${err.message}`, `Could not load the plugin "${name}": ${err.message}`), [
+        L(`Instálalo en el proyecto: npm install --save-dev ${name}`, `Install it in the project: npm install --save-dev ${name}`),
+      ]);
+    }
+    const exported = mod.default ?? mod;
+    const plugin = typeof exported === 'function' ? await exported(options ?? {}) : exported;
+    if (!plugin || typeof plugin !== 'object' || typeof plugin.name !== 'string')
+      throw new BuildError(
+        L(
+          `El plugin "${name}" debe exportar un objeto con "name" o una función que lo devuelva.`,
+          `The plugin "${name}" must export an object with "name" or a function that returns one.`,
+        ),
+      );
+    out.push(plugin);
+  }
+  return out;
+}
+
+async function call(plugin, hook, arg, where = '') {
+  try {
+    return await plugin[hook](arg);
+  } catch (err) {
+    throw new BuildError(
+      L(
+        `El plugin "${plugin.name}" falló en ${hook}${where}: ${err.message}`,
+        `The plugin "${plugin.name}" failed in ${hook}${where}: ${err.message}`,
+      ),
+    );
+  }
+}
+
+/** Ejecuta un gancho sin valor de retorno (buildStart, buildEnd) en todos los plugins, en orden. */
+export async function runHook(plugins, hook, arg) {
+  for (const p of plugins) if (typeof p[hook] === 'function') await call(p, hook, arg);
+}
+
+/** Pasa el código de un archivo por los transform de todos los plugins, en orden. */
+export async function runTransform(plugins, rel, code) {
+  let current = code;
+  for (const p of plugins) {
+    if (typeof p.transform !== 'function') continue;
+    if (p.filter instanceof RegExp && !p.filter.test(rel)) continue;
+    const r = await call(p, 'transform', { path: rel, code: current }, ` (${rel})`);
+    if (typeof r === 'string') current = r;
+    else if (r != null)
+      throw new BuildError(
+        L(
+          `El plugin "${p.name}" devolvió algo que no es texto en transform (${rel}).`,
+          `The plugin "${p.name}" returned something that is not text from transform (${rel}).`,
+        ),
+      );
+  }
+  return current;
+}