@makroz/web 1.2.6-rc14 → 1.3.0

package/bin/mk-update.js

@@ -57,10 +57,125 @@ function getLatestRegistryVersion(packageName) {
   return 'unknown';
 }
 
+function getRegistryVersions(packageName) {
+  try {
+    const stdout = execSync(`npm view ${packageName} versions --json`, {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 5000,
+    });
+    if (stdout.trim()) {
+      const parsed = JSON.parse(stdout.trim());
+      return Array.isArray(parsed) ? parsed : [parsed];
+    }
+  } catch {
+    try {
+      const stdout = execSync(`npm view ${packageName} versions`, {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 5000,
+      });
+      if (stdout.trim()) {
+        return stdout.replace(/[\[\]']/g, '').split(',').map(v => v.trim()).filter(Boolean);
+      }
+    } catch {
+      // silent fallback
+    }
+  }
+  return [];
+}
+
+function parseVersion(v) {
+  const clean = v.replace(/^v/, '');
+  const [main, prerelease] = clean.split('-');
+  const [major, minor, patch] = main.split('.').map(Number);
+  return {
+    major: isNaN(major) ? 0 : major,
+    minor: isNaN(minor) ? 0 : minor,
+    patch: isNaN(patch) ? 0 : patch,
+    prerelease: prerelease || null,
+  };
+}
+
+function compareVersions(v1, v2) {
+  const p1 = parseVersion(v1);
+  const p2 = parseVersion(v2);
+
+  if (p1.major !== p2.major) return p1.major - p2.major;
+  if (p1.minor !== p2.minor) return p1.minor - p2.minor;
+  if (p1.patch !== p2.patch) return p1.patch - p2.patch;
+
+  if (p1.prerelease && !p2.prerelease) return -1;
+  if (!p1.prerelease && p2.prerelease) return 1;
+
+  if (p1.prerelease && p2.prerelease) {
+    const regex = /^([a-zA-Z.-]+)(\d*)$/;
+    const m1 = p1.prerelease.match(regex);
+    const m2 = p2.prerelease.match(regex);
+
+    if (m1 && m2) {
+      const label1 = m1[1];
+      const label2 = m2[1];
+      if (label1 !== label2) {
+        return label1.localeCompare(label2);
+      }
+      const num1 = m1[2] ? parseInt(m1[2], 10) : 0;
+      const num2 = m2[2] ? parseInt(m2[2], 10) : 0;
+      return num1 - num2;
+    }
+    return p1.prerelease.localeCompare(p2.prerelease);
+  }
+
+  return 0;
+}
+
+function performUpdate(updates, packageManager) {
+  const pkgJsonPath = path.join(process.cwd(), 'package.json');
+  const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+
+  const dependencies = pkg.dependencies || {};
+  const devDependencies = pkg.devDependencies || {};
+
+  updates.forEach(upd => {
+    const newSpec = upd.isLocal ? `file:../../mk-director/packages/${upd.name.replace('@makroz/', 'mk-')}` : `^${upd.version}`;
+    if (dependencies[upd.name]) {
+      dependencies[upd.name] = newSpec;
+    } else if (devDependencies[upd.name]) {
+      devDependencies[upd.name] = newSpec;
+    }
+  });
+
+  fs.writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+  console.log('\n✅ package.json actualizado.');
+
+  let command = '';
+  if (packageManager === 'pnpm') {
+    command = 'pnpm install';
+  } else if (packageManager === 'yarn') {
+    command = 'yarn install';
+  } else {
+    command = 'npm install';
+  }
+
+  console.log(`\nEjecutando: ${command}...\n`);
+
+  try {
+    execSync(command, { stdio: 'inherit' });
+    console.log('\n🏁 Actualización finalizada con éxito.\n');
+  } catch (e) {
+    console.error(`\n❌ Error al ejecutar la actualización: ${e.message}\n`);
+    process.exit(1);
+  }
+}
+
 async function run() {
   const args = process.argv.slice(2);
   const toLocal = args.includes('--local') || args.includes('--dev');
   const toProd = args.includes('--prod') || args.includes('--registry') || args.includes('--remote');
+  const dryRun = args.includes('--dry-run');
+
+  const cleanArgs = args.filter(arg => !['--local', '--dev', '--prod', '--registry', '--remote', '--dry-run'].includes(arg));
+  const targetVersionArg = cleanArgs.find(arg => !arg.startsWith('-'));
 
   const pkgJsonPath = path.join(process.cwd(), 'package.json');
   if (!fs.existsSync(pkgJsonPath)) {
@@ -117,6 +232,10 @@ async function run() {
     updateSection(devDependencies);
 
     if (modified) {
+      if (dryRun) {
+        console.log('\n[Simulación] Se omitió la escritura en package.json y la ejecución del gestor de paquetes.');
+        process.exit(0);
+      }
       fs.writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
       console.log('\n✅ package.json actualizado correctamente.');
       const packageManager = detectPackageManager();
@@ -159,37 +278,44 @@ async function run() {
     const isLocal = spec.startsWith('file:');
     const installed = getInstalledVersion(name);
     
-    let latest = 'unknown';
+    let versions = [];
+    let latestStable = 'unknown';
+
     if (isLocal) {
-      latest = getLatestLocalVersion(spec);
+      const localVersion = getLatestLocalVersion(spec);
+      if (localVersion !== 'unknown') {
+        versions = [localVersion];
+      }
     } else {
-      latest = getLatestRegistryVersion(name);
+      versions = getRegistryVersions(name);
+      latestStable = getLatestRegistryVersion(name);
     }
 
-    // Compare versions to see if update is needed
-    let needsUpdate = false;
-    if (installed !== 'unknown' && latest !== 'unknown') {
-      needsUpdate = installed !== latest;
-    } else if (installed === 'unknown' && latest !== 'unknown') {
-      needsUpdate = true;
+    let higherVersions = [];
+    if (installed !== 'unknown') {
+      higherVersions = versions.filter(v => compareVersions(v, installed) > 0);
+    } else {
+      higherVersions = versions;
     }
 
+    higherVersions.sort((a, b) => compareVersions(b, a));
+
     packageInfos.push({
       name,
       currentSpec: spec,
       installedVersion: installed,
-      latestVersion: latest,
+      higherVersions,
+      latestStable,
       isLocal,
-      needsUpdate,
+      needsUpdate: higherVersions.length > 0,
     });
   }
 
-  // Print summary of packages
   console.log('Estado de los paquetes:');
   for (const info of packageInfos) {
     const typeLabel = info.isLocal ? '[Local]' : '[Registry]';
     if (info.needsUpdate) {
-      console.log(`  ⚠️  ${info.name} ${typeLabel}: ${info.installedVersion} -> ${info.latestVersion} (Actualización disponible)`);
+      console.log(`  ⚠️  ${info.name} ${typeLabel}: ${info.installedVersion} -> ${info.higherVersions[0]} (Actualizaciones disponibles: ${info.higherVersions.length})`);
     } else {
       console.log(`  ✅ ${info.name} ${typeLabel}: ${info.installedVersion} (Al día)`);
     }
@@ -205,45 +331,123 @@ async function run() {
   const packageManager = detectPackageManager();
   console.log(`\nGestor de paquetes detectado: ${packageManager}`);
 
+  if (targetVersionArg) {
+    const targetVersionClean = targetVersionArg.replace(/^v/, '');
+    console.log(`\n📌 Versión especificada por argumento: v${targetVersionClean}`);
+    
+    if (dryRun) {
+      console.log(`[Simulación] Se actualizarían los siguientes paquetes a v${targetVersionClean}:`);
+      updatable.forEach(info => console.log(`  - ${info.name}`));
+      process.exit(0);
+    }
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    rl.question(`\n¿Confirmás la actualización a v${targetVersionClean}? (Y/n): `, (answer) => {
+      rl.close();
+      if (answer.trim().toLowerCase() === 'n') {
+        console.log('Actualización cancelada.');
+        process.exit(0);
+      }
+      performUpdate(updatable.map(info => ({ name: info.name, version: targetVersionClean, isLocal: info.isLocal })), packageManager);
+    });
+    return;
+  }
+
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
   });
 
-  rl.question('\n¿Querés actualizar los paquetes? (Y/n): ', (answer) => {
-    rl.close();
-    const confirmed = answer.trim().toLowerCase() !== 'n';
+  const selectedUpdates = [];
 
-    if (!confirmed) {
-      console.log('Actualización cancelada por el usuario.');
-      process.exit(0);
-    }
+  async function askPackageUpdate(index) {
+    if (index >= updatable.length) {
+      rl.close();
+      if (selectedUpdates.length === 0) {
+        console.log('No se seleccionó ninguna actualización.');
+        process.exit(0);
+      }
 
-    const packageNames = updatable.map(info => info.name);
-    let command = '';
+      console.log('\nSelección de actualizaciones:');
+      selectedUpdates.forEach(upd => {
+        console.log(`  - ${upd.name} -> v${upd.version}`);
+      });
 
-    if (packageManager === 'pnpm') {
-      command = `pnpm update ${packageNames.join(' ')}`;
-    } else if (packageManager === 'yarn') {
-      command = `yarn upgrade ${packageNames.join(' ')}`;
-    } else {
-      // npm
-      const args = updatable.map(info => {
-        return info.isLocal ? info.name : `${info.name}@latest`;
-      }).join(' ');
-      command = `npm install ${args}`;
-    }
+      if (dryRun) {
+        console.log('\n[Simulación] Se omitirá la descarga e instalación.');
+        process.exit(0);
+      }
 
-    console.log(`\nEjecutando: ${command}...\n`);
+      const confirmRl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
 
-    try {
-      execSync(command, { stdio: 'inherit' });
-      console.log('\n🏁 Actualización finalizada con éxito.\n');
-    } catch (e) {
-      console.error(`\n❌ Error al ejecutar la actualización: ${e.message}\n`);
-      process.exit(1);
+      confirmRl.question('\n¿Confirmás la actualización? (Y/n): ', (answer) => {
+        confirmRl.close();
+        if (answer.trim().toLowerCase() === 'n') {
+          console.log('Actualización cancelada.');
+          process.exit(0);
+        }
+        performUpdate(selectedUpdates, packageManager);
+      });
+      return;
     }
-  });
+
+    const info = updatable[index];
+    console.log(`\n----------------------------------------`);
+    console.log(`¿A qué versión querés actualizar ${info.name}? (Actual: ${info.installedVersion})`);
+
+    const choices = info.higherVersions.map((version, i) => {
+      const isLatestStable = version === info.latestStable;
+      const isRc = /rc|alpha|beta/i.test(version);
+      const marker = isLatestStable ? ' ⭐ (última estable)' : (isRc ? ' 🧪 (pre-release)' : '');
+      return {
+        text: `v${version}${marker}`,
+        version,
+      };
+    });
+
+    choices.forEach((choice, i) => {
+      console.log(`  [${i + 1}] ${choice.text}`);
+    });
+    console.log(`  [s] Omitir este paquete`);
+
+    rl.question(`\nIngresá el número de opción (1-${choices.length}) o 's' para omitir [default 1]: `, (ans) => {
+      const cleanAns = ans.trim();
+      if (cleanAns.toLowerCase() === 's') {
+        console.log(`Omitiendo ${info.name}.`);
+        askPackageUpdate(index + 1);
+        return;
+      }
+
+      let choiceIndex = 0;
+      if (cleanAns !== '') {
+        const parsedAns = parseInt(cleanAns, 10);
+        if (isNaN(parsedAns) || parsedAns < 1 || parsedAns > choices.length) {
+          console.log('Opción inválida. Reintentando...');
+          askPackageUpdate(index);
+          return;
+        }
+        choiceIndex = parsedAns - 1;
+      }
+
+      const selectedVersion = choices[choiceIndex].version;
+      selectedUpdates.push({
+        name: info.name,
+        version: selectedVersion,
+        isLocal: info.isLocal,
+      });
+
+      askPackageUpdate(index + 1);
+    });
+  }
+
+  askPackageUpdate(0);
 }
 
 run();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makroz/web",
-  "version": "1.2.6-rc14",
+  "version": "1.3.0",
   "description": "React UI components and hooks for MK-Director web applications",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -33,7 +33,7 @@
   },
   "dependencies": {
     "@tanstack/react-query": "^5.62.0",
-    "@makroz/core": "1.1.6-rc14"
+    "@makroz/core": "1.2.0"
   },
   "peerDependencies": {
     "next": "^16.0.0",