@saulwade/swl-ses 1.5.2 → 1.6.0

package/scripts/lib/ui.js

@@ -82,6 +82,25 @@ function encabezado(titulo, version) {
 // Spinner
 // ---------------------------------------------------------------------------
 
+// Registro global de spinners activos. Permite que las funciones interactivas
+// (preguntarSiNo, preguntarOpcion, preguntarTexto) pausen cualquier spinner en
+// curso antes de crear un readline, evitando que el setInterval del spinner
+// sobreescriba el prompt con `\r`. Origen: bug observado en `swl-ses update`
+// cuando el instalador hace preguntarSiNo dentro del spinner del actualizador.
+const _spinnersActivos = new Set();
+
+function _pausarSpinnersActivos() {
+  for (const sp of _spinnersActivos) {
+    sp._pausar();
+  }
+}
+
+function _reanudarSpinnersActivos() {
+  for (const sp of _spinnersActivos) {
+    sp._reanudar();
+  }
+}
+
 function spinner(mensaje) {
   if (!SOPORTA_COLOR) {
     // Sin TTY: solo mostrar mensaje estático
@@ -91,49 +110,96 @@ function spinner(mensaje) {
       exito: (msg) => { console.log(`  [OK] ${msg}`); },
       fallo: (msg) => { console.log(`  [ERROR] ${msg}`); },
       detener: () => {},
+      _pausar: () => {},
+      _reanudar: () => {},
     };
   }
 
   let frameIdx = 0;
   let textoActual = mensaje;
   let activo = true;
+  let pausado = false;
+  let intervalo = null;
 
-  const intervalo = setInterval(() => {
-    if (!activo) return;
+  function _tick() {
+    if (!activo || pausado) return;
     const frame = SPINNER_FRAMES[frameIdx % SPINNER_FRAMES.length];
     process.stdout.write(`\r  ${color.cyan(frame)} ${textoActual}   `);
     frameIdx++;
-  }, 80);
+  }
+
+  function _arrancarIntervalo() {
+    if (intervalo) return;
+    intervalo = setInterval(_tick, 80);
+  }
+
+  function _detenerIntervalo() {
+    if (intervalo) {
+      clearInterval(intervalo);
+      intervalo = null;
+    }
+  }
 
   function limpiarLinea() {
     process.stdout.write('\r\x1b[2K');
   }
 
+  _arrancarIntervalo();
+
+  // Declarado antes del handle para que las funciones de terminación puedan
+  // removerlo. Origen: F-1 nemesis iter-1 — sin remove, cada spinner deja un
+  // listener muerto en `process` y un loop con N runtimes acumula warnings
+  // de MaxListenersExceeded.
+  const exitHandler = () => { handle.detener(); };
+
   const handle = {
     actualizar(msg) {
       textoActual = msg;
     },
     exito(msg) {
       activo = false;
-      clearInterval(intervalo);
+      _detenerIntervalo();
+      _spinnersActivos.delete(handle);
+      process.removeListener('exit', exitHandler);
       limpiarLinea();
       console.log(`  ${color.verde(icono.check)} ${msg}`);
     },
     fallo(msg) {
       activo = false;
-      clearInterval(intervalo);
+      _detenerIntervalo();
+      _spinnersActivos.delete(handle);
+      process.removeListener('exit', exitHandler);
       limpiarLinea();
       console.log(`  ${color.rojo(icono.cross)} ${msg}`);
     },
     detener() {
       activo = false;
-      clearInterval(intervalo);
+      _detenerIntervalo();
+      _spinnersActivos.delete(handle);
+      process.removeListener('exit', exitHandler);
+      limpiarLinea();
+    },
+    _pausar() {
+      // Pausa el tick para que un readline pueda renderizar el prompt sin
+      // que el spinner lo sobreescriba con `\r`. Limpia la línea para que
+      // el prompt empiece en una columna libre.
+      if (pausado) return;
+      pausado = true;
+      _detenerIntervalo();
       limpiarLinea();
     },
+    _reanudar() {
+      // Reanuda el tick tras el cierre del readline. Solo si el spinner sigue
+      // lógicamente activo (no fue detenido durante la pausa).
+      if (!pausado || !activo) return;
+      pausado = false;
+      _arrancarIntervalo();
+    },
   };
 
-  // Limpieza en caso de que el proceso muera
-  const exitHandler = () => { handle.detener(); };
+  _spinnersActivos.add(handle);
+
+  // Limpieza si el proceso muere antes de exito/fallo/detener
   process.once('exit', exitHandler);
 
   return handle;
@@ -151,19 +217,36 @@ function preguntarSiNo(mensaje, valorDefault = true) {
     }
 
     const hint = valorDefault ? 'S/n' : 's/N';
+    _pausarSpinnersActivos();
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
     });
 
+    // El evento 'close' es la única ruta de finalización. Se garantiza que
+    // se dispare incluso si el callback de question no se ejecuta (Ctrl+C,
+    // EOF, error en stdin). Esto evita el bug donde los spinners quedaban
+    // permanentemente pausados tras un cierre prematuro del readline.
+    let valorFinal = valorDefault;
+    let resuelto = false;
+
+    function finalizar() {
+      if (resuelto) return;
+      resuelto = true;
+      _reanudarSpinnersActivos();
+      resolve(valorFinal);
+    }
+
+    rl.on('close', finalizar);
+
     rl.question(`  ${mensaje} [${hint}] `, (respuesta) => {
-      rl.close();
       const r = respuesta.trim().toLowerCase();
       if (r === '') {
-        resolve(valorDefault);
+        valorFinal = valorDefault;
       } else {
-        resolve(r === 's' || r === 'si' || r === 'sí' || r === 'y' || r === 'yes');
+        valorFinal = r === 's' || r === 'si' || r === 'sí' || r === 'y' || r === 'yes';
       }
+      rl.close(); // dispara 'close' → finalizar(); idempotente vía `resuelto`
     });
   });
 }
@@ -185,6 +268,11 @@ function preguntarOpcion(titulo, opciones, opts = {}) {
       return;
     }
 
+    // Pausar antes de emitir el menú con console.log — si hay spinner activo,
+    // un tick a 80ms puede sobreescribir la primera línea del menú. Origen:
+    // F-2 nemesis iter-1.
+    _pausarSpinnersActivos();
+
     console.log('');
     console.log(`  ${titulo}`);
     console.log('');
@@ -197,21 +285,36 @@ function preguntarOpcion(titulo, opciones, opts = {}) {
 
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const hint = `[1-${opciones.length}, Enter=${opciones[indiceDefault].valor}]`;
+
+    // Ver preguntarSiNo: 'close' garantiza reanudación incluso si el callback
+    // de question no se invoca (Ctrl+C, EOF, error).
+    let valorFinal = opciones[indiceDefault].valor;
+    let resuelto = false;
+
+    function finalizar() {
+      if (resuelto) return;
+      resuelto = true;
+      _reanudarSpinnersActivos();
+      resolve(valorFinal);
+    }
+
+    rl.on('close', finalizar);
+
     rl.question(`  Tu elección ${hint}: `, (respuesta) => {
-      rl.close();
       const r = respuesta.trim();
       if (r === '') {
-        resolve(opciones[indiceDefault].valor);
-        return;
-      }
-      const n = parseInt(r, 10);
-      if (Number.isFinite(n) && n >= 1 && n <= opciones.length) {
-        resolve(opciones[n - 1].valor);
+        valorFinal = opciones[indiceDefault].valor;
       } else {
-        // Permitir también escribir el valor directo si coincide
-        const match = opciones.find(o => o.valor === r);
-        resolve(match ? match.valor : opciones[indiceDefault].valor);
+        const n = parseInt(r, 10);
+        if (Number.isFinite(n) && n >= 1 && n <= opciones.length) {
+          valorFinal = opciones[n - 1].valor;
+        } else {
+          // Permitir también escribir el valor directo si coincide
+          const match = opciones.find(o => o.valor === r);
+          valorFinal = match ? match.valor : opciones[indiceDefault].valor;
+        }
       }
+      rl.close();
     });
   });
 }
@@ -230,10 +333,26 @@ function preguntarTexto(mensaje, valorDefault = '') {
       return;
     }
     const hint = valorDefault ? ` [${valorDefault}]` : '';
+    _pausarSpinnersActivos();
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+    // Ver preguntarSiNo: 'close' garantiza reanudación incluso si el callback
+    // de question no se invoca (Ctrl+C, EOF, error).
+    let valorFinal = valorDefault;
+    let resuelto = false;
+
+    function finalizar() {
+      if (resuelto) return;
+      resuelto = true;
+      _reanudarSpinnersActivos();
+      resolve(valorFinal);
+    }
+
+    rl.on('close', finalizar);
+
     rl.question(`  ${mensaje}${hint}: `, (respuesta) => {
+      valorFinal = respuesta.trim() || valorDefault;
       rl.close();
-      resolve(respuesta.trim() || valorDefault);
     });
   });
 }
@@ -245,6 +364,13 @@ function preguntarTexto(mensaje, valorDefault = '') {
 module.exports = {
   SOPORTA_COLOR,
   ES_TTY,
+  // Exports internos para tests del fix de race spinner/prompt. NO usar en
+  // código de producción — la API estable es spinner() + preguntar*.
+  __internalForTesting: {
+    spinnersActivos: _spinnersActivos,
+    pausarSpinnersActivos: _pausarSpinnersActivos,
+    reanudarSpinnersActivos: _reanudarSpinnersActivos,
+  },
   color,
   icono,
   formatearPaso,

package/scripts/tui/componentes/selector-multi.js

@@ -0,0 +1,189 @@
+'use strict';
+
+/**
+ * Selector múltiple (multi-select / checkbox) para la TUI.
+ * Extensión del selectorCheckbox de scripts/lib/selector-interactivo.js con:
+ *   - Descripciones por item (panel inferior bajo el cursor)
+ *   - Atajos: ↑↓ navegar, espacio toggle, 'a' todos, 'n' ninguno
+ *   - Hint configurable
+ *   - Items deshabilitados respetados
+ *
+ * Diseño:
+ *   - Cada item: { valor, etiqueta, descripcion?, deshabilitado?, preseleccionado? }
+ *   - Resuelve con array de valores seleccionados (en orden de items).
+ *   - Esc resuelve con `null` (señal de cancelación).
+ *
+ * No-TTY: resuelve con los items preseleccionados o con todos si
+ *   `opciones.todosSeleccionadosSiNoTty` está en true.
+ */
+
+const render = require('../lib/render');
+const teclas = require('../lib/teclas');
+const { colores, semantico, iconos } = require('../lib/colores');
+
+/**
+ * @param {object} opciones
+ * @param {string} opciones.titulo
+ * @param {Array<{valor:string,etiqueta:string,descripcion?:string,deshabilitado?:boolean,preseleccionado?:boolean}>} opciones.items
+ * @param {boolean} [opciones.todosSeleccionadosSiNoTty=false]
+ * @returns {Promise<string[]|null>}
+ */
+function selectorMulti(opciones) {
+  const items = opciones.items || [];
+  const titulo = opciones.titulo || 'Selecciona las opciones:';
+
+  // Construir set inicial respetando preseleccionados y deshabilitados
+  const seleccionados = new Set();
+  for (const it of items) {
+    if (it.preseleccionado && !it.deshabilitado) seleccionados.add(it.valor);
+  }
+
+  let cursor = 0;
+  while (cursor < items.length && items[cursor]?.deshabilitado) cursor++;
+  if (cursor >= items.length) cursor = 0;
+
+  return new Promise((resolve) => {
+    if (!render.ES_TTY || !process.stdin.isTTY) {
+      if (opciones.todosSeleccionadosSiNoTty) {
+        resolve(items.filter(i => !i.deshabilitado).map(i => i.valor));
+      } else {
+        resolve(Array.from(seleccionados));
+      }
+      return;
+    }
+
+    function _renderizar() {
+      render.limpiarPantalla();
+      const { cols, rows } = render.obtenerDimensiones();
+
+      render.escribirEn(2, 3, semantico.titulo(titulo));
+      render.escribirEn(3, 3, colores.dim(
+        `${seleccionados.size}/${items.filter(i => !i.deshabilitado).length} seleccionados`
+      ));
+
+      const filaInicio = 5;
+      const maxVisible = Math.min(items.length, rows - 8);
+      let scrollOffset = 0;
+      if (cursor < scrollOffset) scrollOffset = cursor;
+      if (cursor >= scrollOffset + maxVisible) scrollOffset = cursor - maxVisible + 1;
+
+      for (let i = scrollOffset; i < Math.min(items.length, scrollOffset + maxVisible); i++) {
+        const item = items[i];
+        const esCursor = i === cursor;
+        const marcado = seleccionados.has(item.valor);
+        const filaItem = filaInicio + (i - scrollOffset);
+
+        let prefijo;
+        if (item.deshabilitado) {
+          prefijo = colores.dim('  ');
+        } else if (esCursor) {
+          prefijo = semantico.cursor(iconos.cursor + ' ');
+        } else {
+          prefijo = '  ';
+        }
+
+        const checkbox = item.deshabilitado
+          ? colores.dim(iconos.cajaVacia)
+          : (marcado ? semantico.exito(iconos.cajaLlena) : iconos.cajaVacia);
+
+        let etiqueta = item.etiqueta;
+        if (item.deshabilitado) etiqueta = colores.dim(etiqueta);
+        else if (esCursor) etiqueta = colores.negrita(etiqueta);
+
+        render.escribirEn(filaItem, 3, `${prefijo}${checkbox} ${etiqueta}`);
+
+        // Descripción del item bajo cursor
+        if (esCursor && item.descripcion && !item.deshabilitado) {
+          const filaDesc = filaInicio + maxVisible + 1;
+          const desc = render.recortar(colores.dim(item.descripcion), cols - 6);
+          render.escribirEn(filaDesc, 3, desc);
+        }
+      }
+
+      // Indicador de scroll
+      if (scrollOffset + maxVisible < items.length) {
+        render.escribirEn(filaInicio + maxVisible, 3,
+          colores.dim(`${iconos.flechaAbajo} ${items.length - scrollOffset - maxVisible} más`));
+      }
+
+      render.dibujarPiePagina([
+        ['↑↓', 'navegar'],
+        ['Space', 'toggle'],
+        ['a', 'todos'],
+        ['n', 'ninguno'],
+        ['Enter', 'confirmar'],
+        ['Esc', 'cancelar'],
+      ]);
+    }
+
+    render.iniciarModoTui();
+    _renderizar();
+
+    const onResize = () => _renderizar();
+    process.stdout.on('resize', onResize);
+
+    const teclado = teclas.crearTeclado();
+
+    function _moverArriba() {
+      let nuevo = cursor;
+      do {
+        nuevo = nuevo > 0 ? nuevo - 1 : items.length - 1;
+      } while (nuevo !== cursor && items[nuevo]?.deshabilitado);
+      cursor = nuevo;
+      _renderizar();
+    }
+
+    function _moverAbajo() {
+      let nuevo = cursor;
+      do {
+        nuevo = nuevo < items.length - 1 ? nuevo + 1 : 0;
+      } while (nuevo !== cursor && items[nuevo]?.deshabilitado);
+      cursor = nuevo;
+      _renderizar();
+    }
+
+    function _toggle() {
+      const item = items[cursor];
+      if (!item || item.deshabilitado) return;
+      if (seleccionados.has(item.valor)) seleccionados.delete(item.valor);
+      else seleccionados.add(item.valor);
+      _renderizar();
+    }
+
+    function _todos() {
+      for (const it of items) {
+        if (!it.deshabilitado) seleccionados.add(it.valor);
+      }
+      _renderizar();
+    }
+
+    function _ninguno() {
+      seleccionados.clear();
+      _renderizar();
+    }
+
+    function _finalizar(valor) {
+      teclado.desactivar();
+      process.stdout.removeListener('resize', onResize);
+      render.salirModoTui();
+      resolve(valor);
+    }
+
+    teclado.on('up', _moverArriba);
+    teclado.on('down', _moverAbajo);
+    teclado.on('space', _toggle);
+    teclado.on('a', _todos);
+    teclado.on('n', _ninguno);
+    teclado.on('return', () => {
+      // Preservar el orden de los items, no el de inserción al set
+      const resultado = items
+        .filter(it => seleccionados.has(it.valor))
+        .map(it => it.valor);
+      _finalizar(resultado);
+    });
+    teclado.on('escape', () => _finalizar(null));
+    teclado.activar();
+  });
+}
+
+module.exports = { selectorMulti };

package/scripts/tui/componentes/selector-unico.js

@@ -0,0 +1,158 @@
+'use strict';
+
+/**
+ * Selector único (single-select) para la TUI.
+ * Más rico que `preguntarOpcion` de scripts/lib/ui.js: navegación con flechas,
+ * descripciones largas con wrap, soporte para items con etiquetas (badges),
+ * pie de página con atajos, indicador de cursor visible.
+ *
+ * Diseño:
+ *   - Cada item: { valor, etiqueta, descripcion?, badge?, deshabilitado? }
+ *   - El cursor se mueve solo entre items habilitados.
+ *   - Enter resuelve con `items[cursor].valor`.
+ *   - Escape resuelve con `null` (señal de "cancelado").
+ *
+ * No-TTY: resuelve inmediatamente con el item por defecto sin esperar input.
+ */
+
+const render = require('../lib/render');
+const teclas = require('../lib/teclas');
+const { colores, semantico, iconos } = require('../lib/colores');
+
+/**
+ * @param {object} opciones
+ * @param {string} opciones.titulo - Título mostrado arriba de la lista.
+ * @param {Array<{valor:string,etiqueta:string,descripcion?:string,badge?:string,deshabilitado?:boolean}>} opciones.items
+ * @param {number} [opciones.indiceDefault=0]
+ * @param {string} [opciones.hintAtajos] - Hint adicional en el pie (opcional).
+ * @returns {Promise<string|null>} - Valor seleccionado o null si se canceló.
+ */
+function selectorUnico(opciones) {
+  const items = opciones.items || [];
+  const titulo = opciones.titulo || 'Selecciona una opción:';
+  let cursor = opciones.indiceDefault || 0;
+
+  // Asegurar que el cursor inicial caiga en un item habilitado
+  while (cursor < items.length && items[cursor]?.deshabilitado) cursor++;
+  if (cursor >= items.length) cursor = 0;
+
+  return new Promise((resolve) => {
+    if (!render.ES_TTY || !process.stdin.isTTY) {
+      // No-TTY: devolver el item por defecto sin renderizar
+      const valor = items[cursor]?.valor ?? items[0]?.valor ?? null;
+      resolve(valor);
+      return;
+    }
+
+    function _renderizar() {
+      render.limpiarPantalla();
+      const { cols, rows } = render.obtenerDimensiones();
+
+      // Título
+      render.escribirEn(2, 3, semantico.titulo(titulo));
+
+      // Items
+      const filaInicio = 4;
+      const maxVisible = Math.min(items.length, rows - 6);
+      let scrollOffset = 0;
+      if (cursor < scrollOffset) scrollOffset = cursor;
+      if (cursor >= scrollOffset + maxVisible) scrollOffset = cursor - maxVisible + 1;
+
+      for (let i = scrollOffset; i < Math.min(items.length, scrollOffset + maxVisible); i++) {
+        const item = items[i];
+        const esCursor = i === cursor;
+        const filaItem = filaInicio + (i - scrollOffset);
+
+        let prefijo;
+        if (item.deshabilitado) {
+          prefijo = colores.dim('  ');
+        } else if (esCursor) {
+          prefijo = semantico.cursor(iconos.cursor + ' ');
+        } else {
+          prefijo = '  ';
+        }
+
+        // Etiqueta principal
+        let etiqueta = item.etiqueta;
+        if (item.deshabilitado) {
+          etiqueta = colores.dim(etiqueta);
+        } else if (esCursor) {
+          etiqueta = colores.negrita(etiqueta);
+        }
+
+        // Badge opcional
+        const badge = item.badge ? '  ' + semantico.badge(item.badge) : '';
+
+        render.escribirEn(filaItem, 3, prefijo + etiqueta + badge);
+
+        // Descripción solo del item bajo cursor (panel inferior)
+        if (esCursor && item.descripcion && !item.deshabilitado) {
+          const filaDesc = filaInicio + maxVisible + 1;
+          const maxAnchoDesc = cols - 6;
+          const desc = render.recortar(colores.dim(item.descripcion), maxAnchoDesc);
+          render.escribirEn(filaDesc, 3, desc);
+        }
+      }
+
+      // Indicador de scroll si hay más items abajo
+      if (scrollOffset + maxVisible < items.length) {
+        render.escribirEn(filaInicio + maxVisible, 3,
+          colores.dim(`${iconos.flechaAbajo} ${items.length - scrollOffset - maxVisible} más`));
+      }
+
+      // Pie con atajos
+      const atajos = [
+        ['↑↓', 'navegar'],
+        ['Enter', 'elegir'],
+        ['Esc', 'cancelar'],
+      ];
+      if (opciones.hintAtajos) atajos.push([opciones.hintAtajos, '']);
+      render.dibujarPiePagina(atajos);
+    }
+
+    render.iniciarModoTui();
+    _renderizar();
+
+    const onResize = () => _renderizar();
+    process.stdout.on('resize', onResize);
+
+    const teclado = teclas.crearTeclado();
+
+    function _moverArriba() {
+      // Saltar items deshabilitados
+      let nuevo = cursor;
+      do {
+        nuevo = nuevo > 0 ? nuevo - 1 : items.length - 1;
+      } while (nuevo !== cursor && items[nuevo]?.deshabilitado);
+      cursor = nuevo;
+      _renderizar();
+    }
+
+    function _moverAbajo() {
+      let nuevo = cursor;
+      do {
+        nuevo = nuevo < items.length - 1 ? nuevo + 1 : 0;
+      } while (nuevo !== cursor && items[nuevo]?.deshabilitado);
+      cursor = nuevo;
+      _renderizar();
+    }
+
+    function _finalizar(valor) {
+      teclado.desactivar();
+      process.stdout.removeListener('resize', onResize);
+      render.salirModoTui();
+      resolve(valor);
+    }
+
+    teclado.on('up', _moverArriba);
+    teclado.on('down', _moverAbajo);
+    teclado.on('return', () => {
+      const item = items[cursor];
+      if (item && !item.deshabilitado) _finalizar(item.valor);
+    });
+    teclado.on('escape', () => _finalizar(null));
+    teclado.activar();
+  });
+}
+
+module.exports = { selectorUnico };