@enke.dev/bumper 0.0.4 → 0.0.6

package/README.md

@@ -19,12 +19,15 @@ Dependencies are bumped by resolving each package's latest version via the repo'
 manager (`pnpm view` / `npm view`, so private scoped registries + `.npmrc` auth just work),
 rewriting `package.json` specs (preserving `^`/`~`), then letting the package manager reinstall.
 
-Bumps are **peer-aware**: before rewriting, bumper reads the `peerDependencies` of every
-installed dependency (from `node_modules`) and caps each shared dependency to the newest version
-still satisfying every declared peer range. So a preset that peer-pins `typescript` to `6.0.3`
+Bumps are **peer-aware**: before rewriting, bumper reads the `peerDependencies` of every direct
+dependency — for the version it's about to bump _to_, resolved from the registry rather than the
+stale one in `node_modules` — and caps each shared dependency to the newest version still
+satisfying every declared peer range. So a preset that peer-pins `typescript` to `6.0.3`
 (e.g. [`@enke.dev/lint`](https://www.npmjs.com/package/@enke.dev/lint)) holds `typescript` at
 `6.0.3` instead of jumping to a newer major that would break the preset — no per-repo config
-needed, the declaration lives in the dependency itself.
+needed, the declaration lives in the dependency itself. Because the peers are read for the target
+version, a peer newly introduced (or changed) by that bump is honored in the **same run** — no
+second pass needed to converge.
 
 > **Note** — network runs through subprocesses (`curl` for the Node dist index, `pnpm`/`npm view`
 > for versions, `actions-up` via `bunx`), so private-registry auth is handled by the tools that

package/dist/cli.mjs

@@ -2273,6 +2273,19 @@ async function latestVersion(pkg, tool, cwd, run2 = exec) {
     return null;
   }
 }
+async function peerDependenciesOf(pkg, version, tool, cwd, run2 = exec) {
+  try {
+    const { exitCode, stdout } = await run2([tool, "view", `${pkg}@${version}`, "peerDependencies", "--json"], { cwd });
+    const trimmed = stdout.trim();
+    if (exitCode !== 0 || !trimmed) {
+      return {};
+    }
+    const parsed = JSON.parse(trimmed);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
 async function latestVersionInRange(pkg, range, tool, cwd, run2 = exec) {
   try {
     const { exitCode, stdout } = await run2([tool, "view", `${pkg}@${range}`, "version"], { cwd });
@@ -2459,13 +2472,20 @@ import { join as join9 } from "node:path";
 // src/utils/deps.utils.ts
 import { rm } from "node:fs/promises";
 import { join as join7 } from "node:path";
+var LOCKFILES = {
+  ["npm" /* Npm */]: ["package-lock.json", "npm-shrinkwrap.json"],
+  ["pnpm" /* Pnpm */]: ["pnpm-lock.yaml"],
+  ["bun" /* Bun */]: ["bun.lock", "bun.lockb"]
+};
 async function cleanInstall(ctx, installCmd) {
+  const lockfiles = LOCKFILES[ctx.packageManager] ?? [];
   if (ctx.dryRun) {
-    planLine("rm -rf node_modules");
+    planLine(["rm -rf", "node_modules", ...lockfiles].join(" "));
     planLine(installCmd.join(" "));
     return;
   }
   await rm(join7(ctx.cwd, "node_modules"), { recursive: true, force: true });
+  await Promise.all(lockfiles.map((file) => rm(join7(ctx.cwd, file), { force: true })));
   await execOk(installCmd, { cwd: ctx.cwd });
 }
 async function selfUpdate(ctx, cmd) {
@@ -2491,7 +2511,11 @@ var BUCKETS2 = [
   "peerDependencies"
 ];
 var CONCURRENCY = 8;
-var defaultLookups = { latestVersion, latestVersionInRange };
+var defaultLookups = {
+  latestVersion,
+  latestVersionInRange,
+  peerDependencies: peerDependenciesOf
+};
 async function collectPackages(ctx) {
   const entries = await Promise.all(ctx.workspaces.map(async (dir) => [dir, await readPackageJson(dir)]));
   return new Map(entries.filter((entry) => entry[1] !== null));
@@ -2503,13 +2527,20 @@ function collectNames(pkgs, managed) {
 function collectDependencyNames(pkgs) {
   return [...new Set([...pkgs.values()].flatMap((pkg) => Object.keys(allDependencies(pkg))))];
 }
-async function collectPeerCaps(cwd, depNames, managed) {
+async function targetVersion(cwd, dep, latest) {
+  if (latest.has(dep)) {
+    return latest.get(dep) ?? null;
+  }
+  return (await readPackageJson(join8(cwd, "node_modules", dep)))?.version ?? null;
+}
+async function collectPeerCaps(cwd, depNames, latest, managed, tool, lookups) {
   const collected = new Map;
   await Promise.all(depNames.map(async (dep) => {
-    const peers = (await readPackageJson(join8(cwd, "node_modules", dep)))?.peerDependencies;
-    if (!peers) {
+    const version = await targetVersion(cwd, dep, latest);
+    if (!version) {
       return;
     }
+    const peers = await lookups.peerDependencies(dep, version, tool, cwd);
     Object.entries(peers).forEach(([peer, range]) => {
       if (managed.has(peer) || !isPinnable(range) && !isVersionRange(range)) {
         return;
@@ -2553,10 +2584,8 @@ async function upgradeAllWorkspaces(ctx, lookups = defaultLookups) {
     return;
   }
   const tool = viewTool(ctx.packageManager);
-  const [latest, peerCaps] = await Promise.all([
-    resolveLatest(names, tool, ctx.cwd, lookups),
-    collectPeerCaps(ctx.cwd, collectDependencyNames(pkgs), managed)
-  ]);
+  const latest = await resolveLatest(names, tool, ctx.cwd, lookups);
+  const peerCaps = await collectPeerCaps(ctx.cwd, collectDependencyNames(pkgs), latest, managed, tool, lookups);
   await Promise.all([...pkgs].map(async ([dir, pkg]) => {
     if (await rewriteSpecs(pkg, managed, latest, peerCaps, tool, ctx.cwd, lookups)) {
       await writePackageJson(dir, pkg);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enke.dev/bumper",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "license": "MIT",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",