package.json a fondo y semver

// ════════════════════════════════════════════════════════════════════════════
// NIVEL OK — "que funcione"
//
// Por qué es el suelo:
//   Resuelves el caso más común: comparar versiones exactas y aplicar el caret
//   (^) cuando el major es >= 1. Es la lógica correcta para el 90% de los rangos
//   que verás en un package.json de empresa.
//
// Qué falta para subir:
//   No cubre tilde (~) ni el caso especial ^0.x, que se comporta distinto.
// ════════════════════════════════════════════════════════════════════════════

// Versiones publicadas de @teambuilder/heroes (de la más vieja a la más nueva):
const publicadas = ['1.2.0', '1.2.5', '1.3.0', '1.9.9', '2.0.0'];

// Parte una versión "1.2.3" en sus tres números: [1, 2, 3].
function partes(version) {
  // "1.2.3" -> ["1","2","3"] -> [1,2,3]
  return version.split('.').map(Number);
}

// ¿version es mayor o igual que base? Compara major, luego minor, luego patch.
function mayorOIgual(version, base) {
  // [major, minor, patch] de la versión a comprobar
  const v = partes(version);
  // [major, minor, patch] del mínimo
  const b = partes(base);
  for (let i = 0; i < 3; i++) {
    // ya es mayor en este nivel: no hace falta seguir
    if (v[i] > b[i]) return true;
    // ya es menor: descartada
    if (v[i] < b[i]) return false;
  }
  // todos los números iguales: es la misma versión (cumple >=)
  return true;
}

// OK: cubre el caso común -> exacto y caret (^) con major >= 1.
function satisface(rango, version) {
  // caret: compatible hacia adelante, bloquea el major
  if (rango[0] === '^') {
    // quita el ^ para quedarnos con "1.2.5"
    const base = rango.slice(1);
    // el major del rango, p.ej. 1
    const major = partes(base)[0];
    // primer major siguiente, EXCLUIDO: "2.0.0"
    const techo = (major + 1) + '.0.0';
    return mayorOIgual(version, base) && !mayorOIgual(version, techo);
    //     ^ version >= base               ^ version < techo
  }
  // exacto: sin símbolo, tiene que ser esa versión y solo esa
  return version === rango;
}

// No toques esto: prueba tu función e imprime qué versiones admite cada rango.
function probar(rango) {
  const cumplen = publicadas.filter(function (v) { return satisface(rango, v); });
  console.log(rango + ' admite: ' + (cumplen.length ? cumplen.join(', ') : '(ninguna)'));
}

// exacto -> solo 1.2.5
probar('1.2.5');
// caret  -> 1.2.5, 1.3.0, 1.9.9 (no 2.0.0)
probar('^1.2.5');
// tilde  -> (ninguna): aún no implementado en este tier
probar('~1.2.5');

// ════════════════════════════════════════════════════════════════════════════
// NIVEL MEJOR — "cubre los rangos reales"
//
// Por qué supera a OK:
//   Añades tilde (~) y el caso especial ^0.x: ahora cubres los rangos que de
//   verdad aparecen en un package.json. ^0.x es diferente porque con major 0
//   cualquier cambio de minor es potencialmente rompedor; npm lo trata como
//   si el minor fuera el major.
//
// Qué falta para subir:
//   Las tres ramas del if duplican la lógica de "calcular el techo". Excelente
//   lo resuelve extrayendo esa lógica a una función reutilizable.
// ════════════════════════════════════════════════════════════════════════════

// Versiones publicadas de @teambuilder/heroes (de la más vieja a la más nueva):
const publicadas = ['1.2.0', '1.2.5', '1.3.0', '1.9.9', '2.0.0'];

// Parte una versión "1.2.3" en sus tres números: [1, 2, 3].
function partes(version) {
  // "1.2.3" -> [1, 2, 3]
  return version.split('.').map(Number);
}

// ¿version es mayor o igual que base? Compara número a número.
function mayorOIgual(version, base) {
  // [major, minor, patch] de la versión
  const v = partes(version);
  // [major, minor, patch] del mínimo
  const b = partes(base);
  for (let i = 0; i < 3; i++) {
    // mayor en este nivel: cumple
    if (v[i] > b[i]) return true;
    // menor en este nivel: no cumple
    if (v[i] < b[i]) return false;
  }
  // versiones iguales: cumple >=
  return true;
}

// Calcula el techo de un rango caret (^), respetando el caso especial ^0.x.
// Con major >= 1: el techo es el major siguiente (^1.2.3 -> <2.0.0).
// Con major 0 y minor > 0: el minor cuenta como ruptura (^0.2.3 -> <0.3.0).
// Con major 0 y minor 0: solo admite ese patch (^0.0.3 -> <0.0.4).
function techoCaret(base) {
  const p = partes(base);
  // ^1.2.3 -> <2.0.0
  if (p[0] > 0) return (p[0] + 1) + '.0.0';
  // ^0.2.3 -> <0.3.0
  if (p[1] > 0) return '0.' + (p[1] + 1) + '.0';
  // ^0.0.3 -> <0.0.4
  return '0.0.' + (p[2] + 1);
}

// Calcula el techo de un rango tilde (~): bloquea el minor.
// ~1.2.3 admite >= 1.2.3 y < 1.3.0 (solo patches del mismo minor).
function techoTilde(base) {
  const p = partes(base);
  // ~1.2.3 -> <1.3.0
  return p[0] + '.' + (p[1] + 1) + '.0';
}

// Mejor: cubre exacto, caret (con ^0.x) y tilde (~).
function satisface(rango, version) {
  // caret: compatible hacia adelante
  if (rango[0] === '^') {
    // quita el ^ -> "1.2.5" o "0.2.3"
    const base = rango.slice(1);
    return mayorOIgual(version, base) && !mayorOIgual(version, techoCaret(base));
  }
  // tilde: solo patches del mismo minor
  if (rango[0] === '~') {
    // quita el ~ -> "1.2.5"
    const base = rango.slice(1);
    return mayorOIgual(version, base) && !mayorOIgual(version, techoTilde(base));
  }
  // exacto: sin símbolo, solo esa versión
  return version === rango;
}

// No toques esto: prueba tu función e imprime qué versiones admite cada rango.
function probar(rango) {
  const cumplen = publicadas.filter(function (v) { return satisface(rango, v); });
  console.log(rango + ' admite: ' + (cumplen.length ? cumplen.join(', ') : '(ninguna)'));
}

// exacto -> solo 1.2.5
probar('1.2.5');
// caret  -> 1.2.5, 1.3.0, 1.9.9 (no 2.0.0)
probar('^1.2.5');
// tilde  -> 1.2.5 (no 1.3.0)
probar('~1.2.5');

// ════════════════════════════════════════════════════════════════════════════
// NIVEL EXCELENTE — "clean code"
//
// Por qué supera a Mejor:
//   Ves que TODO rango es un intervalo [mínimo, techo): incluido el mínimo,
//   excluido el techo. Esa observación permite una sola función intervalo()
//   que calcula el par [min, techo] según el operador, y satisface queda en
//   una línea: ¿la versión cae dentro de ese intervalo? Sin duplicar la
//   lógica de comparación por cada operador (^, ~, exacto).
// ════════════════════════════════════════════════════════════════════════════

// Versiones publicadas de @teambuilder/heroes (de la más vieja a la más nueva):
const publicadas = ['1.2.0', '1.2.5', '1.3.0', '1.9.9', '2.0.0'];

// Tres números de una versión: "1.2.3" -> [1, 2, 3].
function partes(version) {
  // "1.2.3" -> ["1","2","3"] -> [1, 2, 3]
  return version.split('.').map(Number);
}

// Compara dos versiones número a número: -1 si a<b, 0 si iguales, 1 si a>b.
function comparar(a, b) {
  // [major, minor, patch] de a
  const pa = partes(a);
  // [major, minor, patch] de b
  const pb = partes(b);
  for (let i = 0; i < 3; i++) {
    // el primero que difiere decide
    if (pa[i] !== pb[i]) return pa[i] < pb[i] ? -1 : 1;
  }
  // todos iguales
  return 0;
}

// Todo rango se reduce a un intervalo [minimo, techo): incluido el mínimo, excluido
// el techo. Calcular ese par es lo ÚNICO que cambia entre ^, ~ y exacto.
function intervalo(rango) {
  // detecta el operador
  const op = rango[0] === '^' || rango[0] === '~' ? rango[0] : '=';
  // quita el ^ o ~ si lo hay
  const base = op === '=' ? rango : rango.slice(1);
  // [major, minor, patch] del mínimo
  const p = partes(base);
  // bloquea minor: ~1.2.3 -> <1.3.0
  if (op === '~') return [base, p[0] + '.' + (p[1] + 1) + '.0'];
  // solo esa: 1.2.3 -> <1.2.4
  if (op === '=') return [base, p[0] + '.' + p[1] + '.' + (p[2] + 1)];
  // caret ^1.x -> <2.0.0
  if (p[0] > 0) return [base, (p[0] + 1) + '.0.0'];
  // caret ^0.x -> <0.3.0
  if (p[1] > 0) return [base, '0.' + (p[1] + 1) + '.0'];
  // caret ^0.0.x -> <0.0.4
  return [base, '0.0.' + (p[2] + 1)];
}

// ¿version cae en el intervalo del rango? Una sola línea gracias a intervalo().
function satisface(rango, version) {
  // [minimo, techo]
  const limites = intervalo(rango);
  // version >= minimo
  return comparar(version, limites[0]) >= 0
      // version < techo
      && comparar(version, limites[1]) < 0;
}

// No toques esto: prueba tu función e imprime qué versiones admite cada rango.
function probar(rango) {
  const cumplen = publicadas.filter(function (v) { return satisface(rango, v); });
  console.log(rango + ' admite: ' + (cumplen.length ? cumplen.join(', ') : '(ninguna)'));
}

// exacto -> solo 1.2.5
probar('1.2.5');
// caret  -> 1.2.5, 1.3.0, 1.9.9 (no 2.0.0)
probar('^1.2.5');
// tilde  -> 1.2.5 (no 1.3.0)
probar('~1.2.5');