vanilla-builder 0.0.0-stage → 0.2.0

package/src/urls.js

@@ -0,0 +1,108 @@
+// Clasificación y resolución de referencias (URLs) a archivos del proyecto.
+import path from 'node:path';
+
+const SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+const DYNAMIC = /\{\{|\$\{|<%|<\?|\{%/;
+
+/**
+ * Clasifica una URL tal como aparece en el código fuente.
+ * type: empty | fragment | external | dynamic | root | relative
+ */
+export function classifyUrl(raw) {
+  const value = String(raw ?? '').trim();
+  if (!value) return { type: 'empty', value };
+  if (value.startsWith('#')) return { type: 'fragment', value };
+  if (DYNAMIC.test(value)) return { type: 'dynamic', value };
+  if (value.startsWith('//') || value.startsWith('\\\\') || SCHEME.test(value)) return { type: 'external', value };
+  const cut = value.search(/[?#]/);
+  const rawPath = (cut === -1 ? value : value.slice(0, cut)).replace(/\\/g, '/');
+  const suffix = cut === -1 ? '' : value.slice(cut);
+  let decoded;
+  try {
+    decoded = decodeURIComponent(rawPath);
+  } catch {
+    decoded = rawPath;
+  }
+  return { type: rawPath.startsWith('/') ? 'root' : 'relative', value, path: decoded, rawPath, suffix };
+}
+
+/**
+ * Resuelve una referencia a un archivo del proyecto.
+ * @param {string} raw URL encontrada
+ * @param {string} baseDir carpeta (relativa a root, POSIX) contra la que se resuelven las rutas relativas
+ * @param {{files: Map, ignoredSet?: Set, base: string}} ctx
+ * @param {{page?: boolean}} [opts] page: intenta también carpeta/index.html y ruta.html
+ * @returns {{status: 'ok'|'missing'|'ignored'|'outside'|'skip', rel?: string, info: object}}
+ */
+export function resolveRef(raw, baseDir, ctx, opts = {}) {
+  const info = classifyUrl(raw);
+  if (info.type !== 'root' && info.type !== 'relative') return { status: 'skip', info };
+  let rel;
+  if (info.type === 'root') {
+    const base = ctx.base || '/';
+    if (info.path.startsWith(base)) rel = info.path.slice(base.length);
+    else if (`${info.path}/` === base) rel = '';
+    else return { status: 'outside', info };
+  } else {
+    rel = path.posix.join(baseDir || '.', info.path);
+  }
+  rel = path.posix.normalize(rel);
+  if (rel === '.' || rel === './') rel = '';
+  if (rel === '..' || rel.startsWith('../')) return { status: 'outside', info };
+  const isDirLike = rel === '' || rel.endsWith('/') || info.path.endsWith('/');
+  const candidates = [];
+  if (!isDirLike) candidates.push(rel);
+  if (opts.page || isDirLike) {
+    const dir = rel.replace(/\/$/, '');
+    candidates.push(dir ? `${dir}/index.html` : 'index.html');
+    if (!isDirLike && !path.posix.extname(rel)) candidates.push(`${rel}.html`);
+  }
+  const lowerMap = ctx.lowerMap;
+  for (const c of candidates) {
+    if (ctx.files.has(c)) return { status: 'ok', rel: c, info };
+  }
+  // Convención de TypeScript: se escribe "./x.js" y el archivo es x.ts (su salida será justo x.js).
+  const ts = !isDirLike && /\.(m|c)?js$/i.test(rel) ? rel.replace(/\.(m|c)?js$/i, (_, p) => `.${p ?? ''}ts`) : null;
+  if (ts && ctx.files.has(ts)) return { status: 'ok', rel: ts, info };
+  for (const c of candidates) {
+    if (ctx.ignoredSet?.has(c)) return { status: 'ignored', rel: c, info };
+    // Diferencia solo de mayúsculas: en Windows funciona, en un servidor Linux no.
+    const ci = lowerMap?.get(c.toLowerCase());
+    if (ci) return { status: 'case', rel: ci, info };
+  }
+  return { status: 'missing', rel: candidates[0] ?? rel, info };
+}
+
+/** Divide un atributo srcset en candidatos {url, start, end} (posiciones relativas al valor). */
+export function parseSrcset(value) {
+  const out = [];
+  let i = 0;
+  const n = value.length;
+  const isWs = (c) => c === ' ' || c === '\t' || c === '\n' || c === '\r' || c === '\f';
+  while (i < n) {
+    while (i < n && (isWs(value[i]) || value[i] === ',')) i++;
+    if (i >= n) break;
+    const start = i;
+    while (i < n && !isWs(value[i])) i++;
+    let end = i;
+    let url = value.slice(start, end);
+    let hasDescriptor = true;
+    if (url.endsWith(',')) {
+      while (url.endsWith(',')) url = url.slice(0, -1);
+      end = start + url.length;
+      hasDescriptor = false;
+    }
+    if (url) out.push({ url, start, end });
+    if (hasDescriptor) {
+      let depth = 0;
+      while (i < n) {
+        const c = value[i];
+        if (c === '(') depth++;
+        else if (c === ')') depth = Math.max(0, depth - 1);
+        else if (c === ',' && depth === 0) break;
+        i++;
+      }
+    }
+  }
+  return out;
+}

package/src/util.js

@@ -0,0 +1,155 @@
+// Utilidades compartidas: rutas, hashes, codificación y errores.
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export class BuildError extends Error {
+  constructor(message, details = []) {
+    super(message);
+    this.name = 'BuildError';
+    this.details = details;
+  }
+}
+
+export const toPosix = (p) => p.split(path.sep).join('/');
+
+/** Ruta relativa POSIX de `abs` respecto a `root`; null si queda fuera. */
+export function relFrom(root, abs) {
+  const rel = path.relative(root, abs);
+  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return rel === '' ? '' : null;
+  return toPosix(rel);
+}
+
+export const isInside = (parent, child) => {
+  const rel = path.relative(parent, child);
+  return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+};
+
+export function sha256(data) {
+  return crypto.createHash('sha256').update(data).digest();
+}
+
+/** Hash corto y estable (hexadecimal) para nombres de archivo. */
+export const shortHash = (data, length = 8) => sha256(data).toString('hex').slice(0, length);
+
+export function sri(data, algo = 'sha384') {
+  return `${algo}-${crypto.createHash(algo).update(data).digest('base64')}`;
+}
+
+// ignoreBOM: true deja el BOM en el texto para poder detectarlo y conservarlo.
+const strictDecoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+
+/** Devuelve el texto si el buffer es UTF-8 válido; null si no (se copiará tal cual). */
+export function decodeUtf8(buf) {
+  try {
+    return strictDecoder.decode(buf);
+  } catch {
+    return null;
+  }
+}
+
+export const BOM = '';
+export function stripBom(text) {
+  return text.charCodeAt(0) === 0xfeff ? { text: text.slice(1), bom: true } : { text, bom: false };
+}
+
+export const extOf = (p) => path.posix.extname(p).toLowerCase();
+
+// TypeScript se transpila al empezar y desde ahí se trata como JavaScript (sale con extensión .js).
+export const TS_EXT = new Set(['.ts', '.mts', '.cts']);
+export const JS_EXT = new Set(['.js', '.mjs', '.cjs', ...TS_EXT]);
+/** Ruta de salida de un script: app.ts → app.js, x.mts → x.mjs, x.cts → x.cjs. */
+export const jsOutPath = (rel) => rel.replace(/\.(m|c)?ts$/i, (_, p) => `.${(p ?? '').toLowerCase()}js`);
+export const CSS_EXT = new Set(['.css']);
+export const HTML_EXT = new Set(['.html', '.htm']);
+export const JSON_EXT = new Set(['.json', '.webmanifest', '.map']);
+
+/** Ruta URL relativa de un archivo de salida a otro (ambos relativos a outDir, POSIX). */
+export function relativeUrl(fromFileRel, toFileRel) {
+  const fromDir = path.posix.dirname(fromFileRel);
+  let rel = path.posix.relative(fromDir === '.' ? '' : fromDir, toFileRel);
+  if (!rel.startsWith('.')) rel = `./${rel}`;
+  return encodePath(rel);
+}
+
+/** Prefijo relativo desde el directorio de un archivo hasta la raíz de salida ("." o "../.."). */
+export function rootPrefix(fromFileRel) {
+  const depth = path.posix.dirname(fromFileRel) === '.' ? 0 : path.posix.dirname(fromFileRel).split('/').length;
+  return depth === 0 ? '.' : Array(depth).fill('..').join('/');
+}
+
+export const encodePath = (p) =>
+  p
+    .split('/')
+    .map((seg) => (seg === '.' || seg === '..' ? seg : encodeURIComponent(seg)))
+    .join('/');
+
+export function formatBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(2)} MB`;
+}
+
+export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** Reintenta operaciones de disco que en Windows/OneDrive fallan por bloqueos momentáneos. */
+export async function retryFs(fn, attempts = 12) {
+  for (let i = 0; ; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (i >= attempts - 1 || !['EPERM', 'EBUSY', 'EACCES', 'ENOTEMPTY', 'EEXIST'].includes(err.code)) throw err;
+      await sleep(50 * (i + 1));
+    }
+  }
+}
+
+export const unique = (arr) => [...new Set(arr)];
+
+// Compatibilidad con Node 16 (Object.hasOwn llegó en 16.9; fs.cp en 16.7 como experimental).
+export const hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+
+/** Copia recursiva de carpetas. */
+export async function copyDir(src, dest) {
+  await fs.promises.mkdir(dest, { recursive: true });
+  for (const entry of await fs.promises.readdir(src, { withFileTypes: true })) {
+    const from = path.join(src, entry.name);
+    const to = path.join(dest, entry.name);
+    if (entry.isDirectory()) await copyDir(from, to);
+    else await retryFs(() => fs.promises.copyFile(from, to));
+  }
+}
+
+/** Lista recursiva de archivos (rutas relativas POSIX). */
+export function listFiles(dir, base = dir) {
+  const out = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const abs = path.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...listFiles(abs, base));
+    else out.push(toPosix(path.relative(base, abs)));
+  }
+  return out;
+}
+
+/** Quita espacios fuera de las cadenas de un JSON válido. No toca ningún valor (sin pérdida). */
+export function minifyJsonText(text) {
+  try {
+    JSON.parse(text);
+  } catch {
+    return null;
+  }
+  let out = '';
+  let inStr = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (inStr) {
+      out += c;
+      if (c === '\\') out += text[++i];
+      else if (c === '"') inStr = false;
+    } else if (c === '"') {
+      inStr = true;
+      out += c;
+    } else if (c !== ' ' && c !== '\t' && c !== '\n' && c !== '\r') out += c;
+  }
+  return out;
+}

package/src/verify.js

@@ -0,0 +1,138 @@
+// Verificación de la salida antes de publicarla: referencias, sintaxis, escritura y cobertura.
+import fs from 'node:fs';
+import path from 'node:path';
+import { jsImports } from './jsimports.js';
+import { mapLimit } from './compress.js';
+import { parseHtml } from './html.js';
+import { classifyUrl, parseSrcset } from './urls.js';
+
+function unescapeCss(s) {
+  return s.replace(/\\([0-9a-f]{1,6}[ \t\n]?|[\s\S])/gi, (_, e) => (/^[0-9a-f]/i.test(e) ? String.fromCodePoint(parseInt(e, 16)) : e));
+}
+
+function stringEnd(css, i) {
+  const q = css[i];
+  let j = i + 1;
+  while (j < css.length && css[j] !== q) j += css[j] === '\\' ? 2 : 1;
+  return j;
+}
+
+/** URLs de url() e @import de una hoja de estilos. */
+export function cssRefs(css) {
+  const refs = [];
+  let i = 0;
+  while (i < css.length) {
+    const c = css[i];
+    if (c === '/' && css[i + 1] === '*') {
+      const e = css.indexOf('*/', i + 2);
+      i = e < 0 ? css.length : e + 2;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      const end = stringEnd(css, i);
+      if (/@import\s*$/i.test(css.slice(Math.max(0, i - 12), i))) refs.push(unescapeCss(css.slice(i + 1, end)));
+      i = end + 1;
+      continue;
+    }
+    if ((c === 'u' || c === 'U') && /^url\(/i.test(css.slice(i, i + 4)) && !/[\w-]/.test(css[i - 1] ?? '')) {
+      let j = i + 4;
+      while (/\s/.test(css[j] ?? '')) j++;
+      if (css[j] === '"' || css[j] === "'") {
+        const end = stringEnd(css, j);
+        refs.push(unescapeCss(css.slice(j + 1, end)));
+        i = end + 1;
+        continue;
+      }
+      let close = j;
+      while (close < css.length && css[close] !== ')') close += css[close] === '\\' ? 2 : 1;
+      refs.push(unescapeCss(css.slice(j, close).trim()));
+      i = close + 1;
+      continue;
+    }
+    i++;
+  }
+  return refs;
+}
+
+/**
+ * @param {string} staging carpeta temporal escrita
+ * @param {Map<string, object>} outputs archivos generados (rel → {data|copyFrom, type, size})
+ * @param {object} ctx contexto del builder (base, referencias rotas en el origen, cobertura)
+ */
+export async function verifyOutput(staging, outputs, ctx) {
+  const errors = [];
+  const warnings = [];
+  const stats = { files: 0, html: 0, css: 0, js: 0, refs: 0 };
+  const lower = new Map([...outputs.keys()].map((k) => [k.toLowerCase(), k]));
+  const exists = (rel) => outputs.has(rel);
+  const check = (fromRel, url, baseDir, { page = false, srcset = false } = {}) => {
+    const urls = srcset ? parseSrcset(url).map((c) => c.url) : [url];
+    for (const u of urls) {
+      const info = classifyUrl(u);
+      if (info.type !== 'root' && info.type !== 'relative') continue;
+      if (ctx.brokenValues.has(u)) continue; // ya estaba rota en el código fuente
+      stats.refs++;
+      let rel;
+      if (info.type === 'root') {
+        if (!info.path.startsWith(ctx.cfg.base)) continue;
+        rel = info.path.slice(ctx.cfg.base.length);
+      } else rel = path.posix.normalize(path.posix.join(baseDir || '.', info.path));
+      if (rel === '.' || rel === './') rel = '';
+      if (rel === '..' || rel.startsWith('../')) continue; // fuera del sitio: no se puede comprobar
+      const candidates = rel === '' || rel.endsWith('/') ? [`${rel}index.html`] : page ? [rel, `${rel}/index.html`, `${rel}.html`] : [rel];
+      if (candidates.some(exists)) continue;
+      const ci = candidates.map((c) => lower.get(c.toLowerCase())).find(Boolean);
+      errors.push(`${fromRel}: la referencia "${u}" no existe en la salida${ci ? ` (existe "${ci}" con otras mayúsculas)` : ''}.`);
+    }
+  };
+
+  // Parseo de los JS generados: en paralelo (hilos) y con caché por contenido; el resultado es el mismo.
+  const parse = (code, isModule) => (ctx.heavy ? ctx.heavy.imports(code, isModule) : jsImports(code, isModule));
+  const jsList = [...outputs].filter(([, o]) => o.type === 'js' && !o.copyFrom);
+  const parsed = new Map(await mapLimit(jsList, 64, async ([rel, o]) => [rel, await parse(o.data.toString('utf8'), !!o.module)]));
+
+  for (const [rel, o] of outputs) {
+    stats.files++;
+    const dest = path.join(staging, rel);
+    let st;
+    try {
+      st = fs.statSync(dest);
+    } catch {
+      errors.push(`${rel}: no se escribió en disco.`);
+      continue;
+    }
+    const expected = o.copyFrom ? o.size : Buffer.byteLength(o.data);
+    if (st.size !== expected) errors.push(`${rel}: tamaño en disco ${st.size} ≠ esperado ${expected}.`);
+    if (o.copyFrom) continue;
+    const dir = path.posix.dirname(rel) === '.' ? '' : path.posix.dirname(rel);
+    if (o.type === 'html') {
+      stats.html++;
+      const text = o.encoding === 'latin1' ? o.data.toString('latin1') : o.data.toString('utf8');
+      const model = parseHtml(text);
+      const baseDir = o.baseDir ?? dir;
+      if (o.baseExternal) continue;
+      for (const s of model.scripts) {
+        if (s.src) check(rel, s.src.value, baseDir);
+        if (s.inline && s.kind === 'module') {
+          const r = jsImports(s.inline.code, true);
+          if (r.error) errors.push(`${rel}: un <script type="module"> inline no es JS válido (${r.error}).`);
+          else for (const spec of r.imports) if (/^\.{0,2}\//.test(spec)) check(rel, spec, baseDir);
+        }
+      }
+      for (const l of model.links) if (l.type === 'stylesheet' || l.type === 'asset' || l.type === 'preload') check(rel, l.href.value, baseDir);
+      for (const r of model.refs) if (!r.soft) check(rel, r.value, baseDir, { page: r.kind === 'page', srcset: r.kind === 'srcset' });
+    } else if (o.type === 'css') {
+      stats.css++;
+      for (const u of cssRefs(o.data.toString('utf8'))) check(rel, u, dir);
+    } else if (o.type === 'js') {
+      stats.js++;
+      const r = parsed.get(rel);
+      if (r.error) errors.push(`${rel}: el JavaScript generado no es válido (${r.error}).`);
+      else for (const spec of r.imports) if (/^\.{0,2}\//.test(spec)) check(rel, spec, dir);
+    }
+  }
+
+  const missing = [...ctx.files.keys()].filter((rel) => !ctx.coverage.has(rel));
+  for (const rel of missing) errors.push(`${rel}: Builder no registró qué hizo con este archivo (no se publicaría).`);
+  return { errors, warnings, stats };
+}

package/src/watch.js

@@ -0,0 +1,60 @@
+// Vigila una carpeta y sus subcarpetas. fs.watch recursivo no existe en Linux antes de Node 20:
+// en ese caso se vigila cada carpeta por separado y se añaden las nuevas al vuelo.
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * @param {string} root
+ * @param {(rel: string) => boolean} ignore recibe la ruta relativa (POSIX) y devuelve true para ignorarla
+ * @param {(rel: string) => void} onChange
+ * @returns {() => void} función para dejar de vigilar
+ */
+export function watchTree(root, ignore, onChange) {
+  const emit = (abs) => {
+    const rel = path.relative(root, abs).split(path.sep).join('/');
+    if (rel && !rel.startsWith('..') && !ignore(rel)) onChange(rel);
+  };
+  try {
+    const w = fs.watch(root, { recursive: true }, (_e, name) => name && emit(path.join(root, name.toString())));
+    return () => w.close();
+  } catch (err) {
+    if (err.code !== 'ERR_FEATURE_UNAVAILABLE_ON_PLATFORM') throw err;
+  }
+  const watchers = new Map();
+  const add = (dir) => {
+    if (watchers.has(dir)) return;
+    const rel = path.relative(root, dir).split(path.sep).join('/');
+    if (rel && ignore(rel)) return;
+    try {
+      watchers.set(
+        dir,
+        fs.watch(dir, (_e, name) => {
+          if (!name) return;
+          const abs = path.join(dir, name.toString());
+          try {
+            if (fs.statSync(abs).isDirectory()) addTree(abs);
+          } catch {
+            /* borrado */
+          }
+          emit(abs);
+        }),
+      );
+    } catch {
+      /* sin permiso o borrada */
+    }
+  };
+  const addTree = (dir) => {
+    add(dir);
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) if (e.isDirectory()) addTree(path.join(dir, e.name));
+  };
+  addTree(root);
+  return () => {
+    for (const w of watchers.values()) w.close();
+  };
+}

package/src/worker.js

@@ -0,0 +1,26 @@
+// Hilo de trabajo: ofusca o comprime con terser fuera del hilo principal.
+import { parentPort, workerData } from 'node:worker_threads';
+import { ensureObfuscator, obfuscateSafe } from './obfuscate.js';
+import { importOptional } from './optional.js';
+import { terserMinify } from './tersercore.js';
+import { jsImports } from './jsimports.js';
+
+let terser = null;
+
+parentPort.on('message', async ({ id, kind, payload }) => {
+  try {
+    let result;
+    if (kind === 'obfuscate') {
+      await ensureObfuscator(workerData.root);
+      result = obfuscateSafe(payload.code, payload.opts);
+    } else if (kind === 'terser') {
+      terser ??= await importOptional('terser', workerData.root, 'para la compresión máxima');
+      result = await terserMinify(terser, payload.code, payload.opts);
+    } else if (kind === 'imports') {
+      result = jsImports(payload.code, payload.opts.isModule);
+    } else throw new Error(`tarea desconocida: ${kind}`);
+    parentPort.postMessage({ id, result });
+  } catch (err) {
+    parentPort.postMessage({ id, error: String(err?.message ?? err) });
+  }
+});