update-versions 7.2.3 → 7.2.5

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## 7.2.5 (2026-09-06)
+
+### Bug Fixes
+
+- **update-versions:** remove p-reduce from package inventory ([22fbf9a](https://github.com/codsen/codsen/commit/22fbf9afe447a3b33c8c6aaee47a28769b7f5f6c))
+- **update-versions:** replace external update notifier ([aee67ab](https://github.com/codsen/codsen/commit/aee67abd0b123e73a89003af55a4ffea04f46881))
+
 ## 7.2.0 (2026-08-19)
 
 ### Bug Fixes

package/README.md

@@ -35,7 +35,7 @@ upd
 
 ## Documentation
 
-Please [visit codsen.com](https://codsen.com/os/update-versions/) for a full description of the API. If you’re looking for the **Changelog**, it’s [here](https://github.com/codsen/codsen/blob/main/packages/update-versions/CHANGELOG.md).
+Please [visit codsen.com](https://codsen.com/os/update-versions/) for a full description of the API. For **Changelog**, see [raw md on GitHub](https://github.com/codsen/codsen/blob/main/packages/update-versions/CHANGELOG.md) or [the website](https://codsen.com/os/update-versions/changelog).
 
 ## Contributing
 

package/cli-update-notifier.js

@@ -0,0 +1,793 @@
+// This is the canonical source. `lect` copies it verbatim into every CLI.
+
+import { spawn } from "node:child_process";
+import {
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const CHECK_INTERVAL = 24 * 60 * 60 * 1000;
+const FAILURE_BACKOFF = 60 * 60 * 1000;
+const FETCH_TIMEOUT = 10 * 1000;
+const LOCK_STALE_AFTER = FETCH_TIMEOUT + 20 * 1000;
+const MAX_JSON_BYTES = 64 * 1024;
+const MODULE_FILENAME = fileURLToPath(import.meta.url);
+const NOTIFICATION_LEASE = 60 * 60 * 1000;
+const STATE_SCHEMA_VERSION = 1;
+const WORKER_FLAG = "--codsen-update-check-worker";
+
+const SEMVER_PATTERN =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+const PACKAGE_NAME_PART = /^[a-z0-9][a-z0-9._~-]*$/;
+
+function parseSemver(version) {
+  if (typeof version !== "string") {
+    return null;
+  }
+  const match = SEMVER_PATTERN.exec(version);
+  if (!match) {
+    return null;
+  }
+  const prerelease = match[4] ? match[4].split(".") : [];
+  if (
+    prerelease.some(
+      (identifier) => /^\d+$/.test(identifier) && /^0\d+/.test(identifier),
+    )
+  ) {
+    return null;
+  }
+  return {
+    core: [match[1], match[2], match[3]],
+    prerelease,
+  };
+}
+
+function compareNumericStrings(left, right) {
+  if (left.length !== right.length) {
+    return left.length < right.length ? -1 : 1;
+  }
+  if (left === right) {
+    return 0;
+  }
+  return left < right ? -1 : 1;
+}
+
+function compareSemver(leftVersion, rightVersion) {
+  const left = parseSemver(leftVersion);
+  const right = parseSemver(rightVersion);
+  if (!left || !right) {
+    return null;
+  }
+  for (let index = 0; index < left.core.length; index += 1) {
+    const comparison = compareNumericStrings(
+      left.core[index],
+      right.core[index],
+    );
+    if (comparison) {
+      return comparison;
+    }
+  }
+  if (!left.prerelease.length || !right.prerelease.length) {
+    if (left.prerelease.length === right.prerelease.length) {
+      return 0;
+    }
+    return left.prerelease.length ? -1 : 1;
+  }
+  const length = Math.max(left.prerelease.length, right.prerelease.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftIdentifier = left.prerelease[index];
+    const rightIdentifier = right.prerelease[index];
+    if (leftIdentifier === undefined || rightIdentifier === undefined) {
+      return leftIdentifier === undefined ? -1 : 1;
+    }
+    if (leftIdentifier === rightIdentifier) {
+      continue;
+    }
+    const leftIsNumeric = /^\d+$/.test(leftIdentifier);
+    const rightIsNumeric = /^\d+$/.test(rightIdentifier);
+    if (leftIsNumeric && rightIsNumeric) {
+      return compareNumericStrings(leftIdentifier, rightIdentifier);
+    }
+    if (leftIsNumeric !== rightIsNumeric) {
+      return leftIsNumeric ? -1 : 1;
+    }
+    return leftIdentifier < rightIdentifier ? -1 : 1;
+  }
+  return 0;
+}
+
+function isValidPackageName(packageName) {
+  if (
+    typeof packageName !== "string" ||
+    !packageName ||
+    packageName.length > 214
+  ) {
+    return false;
+  }
+  if (!packageName.startsWith("@")) {
+    return PACKAGE_NAME_PART.test(packageName);
+  }
+  const parts = packageName.slice(1).split("/");
+  return (
+    parts.length === 2 && parts.every((part) => PACKAGE_NAME_PART.test(part))
+  );
+}
+
+function validTimestamp(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : 0;
+}
+
+function initialState(now, legacy = {}) {
+  const legacyCheck = validTimestamp(legacy.lastUpdateCheck);
+  return {
+    schemaVersion: STATE_SCHEMA_VERSION,
+    createdAt: legacyCheck || now,
+    lastAttempt: 0,
+    lastSuccess: 0,
+    latestVersion: parseSemver(legacy.latestVersion)
+      ? legacy.latestVersion
+      : null,
+    lastNotification: null,
+    pendingNotification: null,
+  };
+}
+
+function normalizeState(value, now) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const latestVersion = parseSemver(value.latestVersion)
+    ? value.latestVersion
+    : null;
+  const notification = value.lastNotification;
+  const lastNotification =
+    notification &&
+    typeof notification === "object" &&
+    parseSemver(notification.current) &&
+    parseSemver(notification.latest)
+      ? {
+          current: notification.current,
+          latest: notification.latest,
+          at: validTimestamp(notification.at),
+        }
+      : null;
+  const pending = value.pendingNotification;
+  const pendingNotification =
+    pending &&
+    typeof pending === "object" &&
+    parseSemver(pending.current) &&
+    parseSemver(pending.latest) &&
+    typeof pending.token === "string" &&
+    pending.token.length <= 256
+      ? {
+          current: pending.current,
+          latest: pending.latest,
+          token: pending.token,
+          at: validTimestamp(pending.at),
+        }
+      : null;
+  return {
+    schemaVersion: STATE_SCHEMA_VERSION,
+    createdAt: validTimestamp(value.createdAt) || now,
+    lastAttempt: validTimestamp(value.lastAttempt),
+    lastSuccess: validTimestamp(value.lastSuccess),
+    latestVersion,
+    lastNotification,
+    pendingNotification,
+  };
+}
+
+function readSmallJson(filename) {
+  if (!filename) {
+    return null;
+  }
+  try {
+    const stats = statSync(filename);
+    if (!stats.isFile() || stats.size > MAX_JSON_BYTES) {
+      return null;
+    }
+    return JSON.parse(readFileSync(filename, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function readState(filename, now) {
+  return normalizeState(readSmallJson(filename), now);
+}
+
+function writeState(filename, state) {
+  let temporaryFilename;
+  try {
+    mkdirSync(path.dirname(filename), { mode: 0o700, recursive: true });
+    temporaryFilename = `${filename}.${process.pid}.${Date.now().toString(36)}.${Math.random().toString(36).slice(2)}.tmp`;
+    writeFileSync(temporaryFilename, `${JSON.stringify(state, null, 2)}\n`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 0o600,
+    });
+    renameSync(temporaryFilename, filename);
+    return true;
+  } catch {
+    if (temporaryFilename) {
+      try {
+        unlinkSync(temporaryFilename);
+      } catch {}
+    }
+    return false;
+  }
+}
+
+function acquireLock(lockFile, now, staleAfter = LOCK_STALE_AFTER) {
+  try {
+    mkdirSync(path.dirname(lockFile), { mode: 0o700, recursive: true });
+  } catch {
+    return false;
+  }
+  const token = `${process.pid}:${Date.now()}:${Math.random()}`;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      writeFileSync(lockFile, token, {
+        encoding: "utf8",
+        flag: "wx",
+        mode: 0o600,
+      });
+      return token;
+    } catch (error) {
+      if (error?.code !== "EEXIST") {
+        return false;
+      }
+      try {
+        const observedToken = readFileSync(lockFile, "utf8");
+        const observedStats = statSync(lockFile);
+        const age = now - observedStats.mtimeMs;
+        if (!Number.isFinite(age) || age <= staleAfter) {
+          return false;
+        }
+        const currentStats = statSync(lockFile);
+        if (
+          readFileSync(lockFile, "utf8") !== observedToken ||
+          currentStats.dev !== observedStats.dev ||
+          currentStats.ino !== observedStats.ino ||
+          currentStats.mtimeMs !== observedStats.mtimeMs
+        ) {
+          return false;
+        }
+        if (readFileSync(lockFile, "utf8") !== observedToken) {
+          return false;
+        }
+        unlinkSync(lockFile);
+      } catch {
+        return false;
+      }
+    }
+  }
+  return false;
+}
+
+function releaseLock(lockFile, token) {
+  try {
+    if (readFileSync(lockFile, "utf8") === token) {
+      unlinkSync(lockFile);
+    }
+  } catch {}
+}
+
+function updateStateWithLock(
+  paths,
+  now,
+  update,
+  staleAfter = LOCK_STALE_AFTER,
+) {
+  const lockToken = acquireLock(paths.lockFile, now, staleAfter);
+  if (!lockToken) {
+    return null;
+  }
+  try {
+    const existingState = readState(paths.cacheFile, now);
+    const nextState = update(existingState || initialState(now), {
+      exists: Boolean(existingState),
+    });
+    return nextState && writeState(paths.cacheFile, nextState)
+      ? nextState
+      : null;
+  } finally {
+    releaseLock(paths.lockFile, lockToken);
+  }
+}
+
+function resolveCacheRoot(env, home, platform) {
+  if (
+    typeof env.XDG_CACHE_HOME === "string" &&
+    path.isAbsolute(env.XDG_CACHE_HOME)
+  ) {
+    return env.XDG_CACHE_HOME;
+  }
+  if (platform === "win32") {
+    if (
+      typeof env.LOCALAPPDATA === "string" &&
+      path.isAbsolute(env.LOCALAPPDATA)
+    ) {
+      return env.LOCALAPPDATA;
+    }
+    return home && path.isAbsolute(home)
+      ? path.join(home, "AppData", "Local")
+      : null;
+  }
+  if (!home || !path.isAbsolute(home)) {
+    return null;
+  }
+  return platform === "darwin"
+    ? path.join(home, "Library", "Caches")
+    : path.join(home, ".cache");
+}
+
+function resolvePaths(packageName, runtime = {}) {
+  const env = runtime.env ?? process.env;
+  const home = runtime.home ?? homedir();
+  const platform = runtime.platform ?? process.platform;
+  const cacheRoot = runtime.cacheRoot ?? resolveCacheRoot(env, home, platform);
+  if (!cacheRoot || !path.isAbsolute(cacheRoot)) {
+    return null;
+  }
+  const encodedName = Buffer.from(packageName).toString("base64url");
+  const directory = path.join(cacheRoot, "codsen", "update-notifier");
+  const cacheFile =
+    runtime.cacheFile ?? path.join(directory, `${encodedName}.json`);
+  const lockFile = runtime.lockFile ?? `${cacheFile}.lock`;
+  const configRoot =
+    env.XDG_CONFIG_HOME || (home && path.join(home, ".config"));
+  const legacyConfigFile =
+    "legacyConfigFile" in runtime
+      ? runtime.legacyConfigFile
+      : configRoot &&
+        path.join(
+          configRoot,
+          "configstore",
+          `update-notifier-${packageName}.json`,
+        );
+  return { cacheFile, legacyConfigFile, lockFile };
+}
+
+function readLegacyConfig(filename) {
+  const value = readSmallJson(filename);
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return {
+    optOut: Boolean(value.optOut),
+    lastUpdateCheck: validTimestamp(value.lastUpdateCheck),
+    latestVersion: value.update?.latest,
+  };
+}
+
+function isCi(env) {
+  return (
+    env.CI !== "0" &&
+    env.CI !== "false" &&
+    ("CI" in env ||
+      "CONTINUOUS_INTEGRATION" in env ||
+      Object.keys(env).some((key) => key.startsWith("CI_")))
+  );
+}
+
+function isPackageManagerInvocation(env) {
+  const userAgent = env.npm_config_user_agent;
+  return (
+    (typeof env.npm_package_json === "string" &&
+      env.npm_package_json.endsWith("package.json")) ||
+    (typeof userAgent === "string" &&
+      ["npm", "yarn", "pnpm", "bun"].some((name) => userAgent.startsWith(name)))
+  );
+}
+
+function isDisabled({
+  argv,
+  enabled,
+  env,
+  packageName,
+  packageVersion,
+  stderr,
+}) {
+  return (
+    enabled === false ||
+    !isValidPackageName(packageName) ||
+    !parseSemver(packageVersion) ||
+    stderr?.isTTY !== true ||
+    "NO_UPDATE_NOTIFIER" in env ||
+    env.NODE_ENV === "test" ||
+    argv.includes("--no-update-notifier") ||
+    isCi(env) ||
+    isPackageManagerInvocation(env)
+  );
+}
+
+function isCheckDue(state, now, options = {}) {
+  const checkInterval = options.checkInterval ?? CHECK_INTERVAL;
+  const failureBackoff = options.failureBackoff ?? FAILURE_BACKOFF;
+  const successOrCreation = state.lastSuccess || state.createdAt;
+  return (
+    now - successOrCreation >= checkInterval &&
+    (!state.lastAttempt || now - state.lastAttempt >= failureBackoff)
+  );
+}
+
+function isNotificationDue(state, currentVersion) {
+  const latestVersion = state.latestVersion;
+  if (compareSemver(latestVersion, currentVersion) !== 1) {
+    return false;
+  }
+  return !(
+    state.lastNotification?.current === currentVersion &&
+    state.lastNotification?.latest === latestVersion
+  );
+}
+
+function formatCliUpdateNotification({
+  currentVersion,
+  latestVersion,
+  packageName,
+}) {
+  return `\nUpdate available for ${packageName}: ${currentVersion} → ${latestVersion}\nhttps://www.npmjs.com/package/${encodeURIComponent(packageName)}\n\n`;
+}
+
+function hasActiveNotificationReservation(
+  state,
+  currentVersion,
+  latestVersion,
+  now,
+  lease,
+) {
+  const pending = state.pendingNotification;
+  return (
+    pending?.current === currentVersion &&
+    pending.latest === latestVersion &&
+    now - pending.at < lease
+  );
+}
+
+function registerNotification({
+  currentVersion,
+  now,
+  onExit,
+  packageName,
+  paths,
+  reservationToken,
+  staleAfter,
+  stderr,
+}) {
+  const finish = (code) => {
+    const notificationTime = now();
+    updateStateWithLock(
+      paths,
+      notificationTime,
+      (state) => {
+        if (state.pendingNotification?.token !== reservationToken) {
+          return null;
+        }
+        if (code !== 0 || stderr?.isTTY !== true) {
+          return { ...state, pendingNotification: null };
+        }
+        const notificationLatest = state.latestVersion;
+        if (compareSemver(notificationLatest, currentVersion) !== 1) {
+          return { ...state, pendingNotification: null };
+        }
+        try {
+          stderr.write(
+            formatCliUpdateNotification({
+              currentVersion,
+              latestVersion: notificationLatest,
+              packageName,
+            }),
+          );
+        } catch {
+          return { ...state, pendingNotification: null };
+        }
+        return {
+          ...state,
+          lastNotification: {
+            current: currentVersion,
+            latest: notificationLatest,
+            at: notificationTime,
+          },
+          pendingNotification: null,
+        };
+      },
+      staleAfter,
+    );
+  };
+  try {
+    onExit(finish);
+    return true;
+  } catch {
+    finish(1);
+    return false;
+  }
+}
+
+function spawnWorker(packageName, attemptToken, spawnImpl = spawn) {
+  try {
+    const child = spawnImpl(
+      process.execPath,
+      [MODULE_FILENAME, WORKER_FLAG, packageName, String(attemptToken)],
+      {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+      },
+    );
+    child.once?.("error", () => {});
+    child.unref?.();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function notifyOfCliUpdate({ enabled = true, pkg } = {}, runtime = {}) {
+  try {
+    const argv = runtime.argv ?? process.argv.slice(2);
+    const env = runtime.env ?? process.env;
+    const stderr = runtime.stderr ?? process.stderr;
+    const packageName = pkg?.name;
+    const packageVersion = pkg?.version;
+    if (
+      isDisabled({
+        argv,
+        enabled,
+        env,
+        packageName,
+        packageVersion,
+        stderr,
+      })
+    ) {
+      return false;
+    }
+    const paths = resolvePaths(packageName, runtime);
+    if (!paths) {
+      return false;
+    }
+    const legacy = readLegacyConfig(paths.legacyConfigFile);
+    if (legacy.optOut) {
+      return false;
+    }
+    const now = runtime.now ?? Date.now;
+    const currentTime = now();
+    const staleAfter = runtime.lockStaleAfter ?? LOCK_STALE_AFTER;
+    let state = readState(paths.cacheFile, currentTime);
+    if (!state) {
+      state = updateStateWithLock(
+        paths,
+        currentTime,
+        (current, { exists }) =>
+          exists ? current : initialState(currentTime, legacy),
+        staleAfter,
+      );
+      if (!state) {
+        return false;
+      }
+    }
+    if (isNotificationDue(state, packageVersion)) {
+      const reservationToken = `${process.pid}:${currentTime}:${Math.random()}`;
+      const claimedState = updateStateWithLock(
+        paths,
+        currentTime,
+        (current) => {
+          const currentLatest = current.latestVersion;
+          return isNotificationDue(current, packageVersion) &&
+            !hasActiveNotificationReservation(
+              current,
+              packageVersion,
+              currentLatest,
+              currentTime,
+              runtime.notificationLease ?? NOTIFICATION_LEASE,
+            )
+            ? {
+                ...current,
+                pendingNotification: {
+                  current: packageVersion,
+                  latest: currentLatest,
+                  token: reservationToken,
+                  at: currentTime,
+                },
+              }
+            : null;
+        },
+        staleAfter,
+      );
+      if (!claimedState) {
+        return false;
+      }
+      return registerNotification({
+        currentVersion: packageVersion,
+        now,
+        onExit:
+          runtime.onExit ?? ((listener) => process.once("exit", listener)),
+        packageName,
+        paths,
+        reservationToken,
+        staleAfter,
+        stderr,
+      });
+    }
+    if (
+      !isCheckDue(state, currentTime, {
+        checkInterval: runtime.checkInterval,
+        failureBackoff: runtime.failureBackoff,
+      })
+    ) {
+      return false;
+    }
+    const scheduledState = updateStateWithLock(
+      paths,
+      currentTime,
+      (current) =>
+        isCheckDue(current, currentTime, {
+          checkInterval: runtime.checkInterval,
+          failureBackoff: runtime.failureBackoff,
+        })
+          ? { ...current, lastAttempt: currentTime }
+          : null,
+      staleAfter,
+    );
+    if (!scheduledState) {
+      return false;
+    }
+    const startWorker = runtime.spawnWorker ?? spawnWorker;
+    return Boolean(startWorker(packageName, currentTime, runtime.spawnImpl));
+  } catch {
+    return false;
+  }
+}
+
+async function readLimitedBody(response) {
+  const contentLength = Number(response.headers?.get?.("content-length"));
+  if (Number.isFinite(contentLength) && contentLength > MAX_JSON_BYTES) {
+    return null;
+  }
+  if (!response.body?.getReader) {
+    const text = await response.text();
+    return Buffer.byteLength(text) <= MAX_JSON_BYTES ? text : null;
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      const chunk = Buffer.from(value);
+      total += chunk.length;
+      if (total > MAX_JSON_BYTES) {
+        await reader.cancel();
+        return null;
+      }
+      chunks.push(chunk);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, total).toString("utf8");
+}
+
+async function fetchLatestVersion(packageName, runtime = {}) {
+  const fetchImpl = runtime.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    return null;
+  }
+  const timeoutMs = runtime.fetchTimeout ?? FETCH_TIMEOUT;
+  const controller = new AbortController();
+  let timeout;
+  const request = Promise.resolve()
+    .then(async () => {
+      const response = await fetchImpl(
+        `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`,
+        {
+          headers: { accept: "application/json" },
+          redirect: "follow",
+          signal: controller.signal,
+        },
+      );
+      if (!response?.ok) {
+        return null;
+      }
+      const body = await readLimitedBody(response);
+      if (body === null) {
+        return null;
+      }
+      const version = JSON.parse(body).version;
+      return parseSemver(version) ? version : null;
+    })
+    .catch(() => null);
+  const timedOut = new Promise((resolve) => {
+    timeout = setTimeout(() => {
+      controller.abort();
+      resolve(null);
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([request, timedOut]);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+async function runUpdateCheck(packageName, runtime = {}) {
+  try {
+    if (!isValidPackageName(packageName)) {
+      return false;
+    }
+    const paths = resolvePaths(packageName, runtime);
+    if (!paths) {
+      return false;
+    }
+    const latestVersion = await fetchLatestVersion(packageName, runtime);
+    if (!latestVersion) {
+      return false;
+    }
+    const now = runtime.now ?? Date.now;
+    const currentTime = now();
+    return Boolean(
+      updateStateWithLock(
+        paths,
+        currentTime,
+        (state) =>
+          runtime.expectedAttempt !== undefined &&
+          state.lastAttempt !== runtime.expectedAttempt
+            ? null
+            : {
+                ...state,
+                lastSuccess: currentTime,
+                latestVersion,
+              },
+        runtime.lockStaleAfter,
+      ),
+    );
+  } catch {
+    return false;
+  }
+}
+
+function isWorkerInvocation(argv = process.argv) {
+  return (
+    argv[1] &&
+    path.resolve(argv[1]) === path.resolve(MODULE_FILENAME) &&
+    argv[2] === WORKER_FLAG
+  );
+}
+
+if (isWorkerInvocation()) {
+  const attemptToken = Number(process.argv[4]);
+  await runUpdateCheck(process.argv[3], {
+    expectedAttempt: Number.isSafeInteger(attemptToken)
+      ? attemptToken
+      : undefined,
+  });
+}
+
+export {
+  compareSemver,
+  fetchLatestVersion,
+  formatCliUpdateNotification,
+  isCheckDue,
+  isCi,
+  isDisabled,
+  isNotificationDue,
+  isPackageManagerInvocation,
+  notifyOfCliUpdate,
+  parseSemver,
+  readLegacyConfig,
+  readState,
+  resolveCacheRoot,
+  resolvePaths,
+  runUpdateCheck,
+};

package/cli.js

@@ -13,9 +13,13 @@ import { codsenCLI, isPlainObject } from "codsen-utils";
 import { del, set } from "edit-package-json";
 import objectPath from "object-path";
 import pProgress, { PProgress } from "p-progress";
-import pReduce from "p-reduce";
 import packageJson from "package-json";
-import updateNotifier from "update-notifier";
+import { notifyOfCliUpdate } from "./cli-update-notifier.js";
+import {
+  major,
+  updatedDependencySpec,
+  workspaceSpecPrefix,
+} from "./dependency-spec.js";
 
 const require1 = createRequire(import.meta.url);
 const pkg = require1("./package.json");
@@ -202,12 +206,6 @@ function parseDependencySpec(dependencyName, currentSpec) {
   };
 }
 
-function workspaceSpecPrefix(parsedSpec) {
-  return parsedSpec.kind === "workspace-alias"
-    ? `workspace:${parsedSpec.targetName}@`
-    : "workspace:";
-}
-
 function pinnedDependencySpec(parsedSpec, currentSpec, pinnedSpec) {
   if (parsedSpec.kind === "registry") {
     return pinnedSpec;
@@ -223,26 +221,6 @@ function pinnedDependencySpec(parsedSpec, currentSpec, pinnedSpec) {
   return `${workspaceSpecPrefix(parsedSpec)}${selector}`;
 }
 
-function updatedDependencySpec(parsedSpec, currentSpec, version) {
-  if (parsedSpec.kind === "registry") {
-    return `^${version}`;
-  }
-  if (parsedSpec.kind === "workspace-path") {
-    return currentSpec;
-  }
-
-  let workspaceRange = parsedSpec.selector;
-  if (["*", "^", "~"].includes(workspaceRange)) {
-    return currentSpec;
-  }
-  let firstVersionDigit = workspaceRange.search(/\d/);
-  if (firstVersionDigit === -1) {
-    return currentSpec;
-  }
-  let rangePrefix = workspaceRange.slice(0, firstVersionDigit);
-  return `${workspaceSpecPrefix(parsedSpec)}${rangePrefix}${version}`;
-}
-
 const helpText = `
   Usage:
     $ upd
@@ -325,15 +303,6 @@ export async function updateVersions({
       .map((n) => `${n} ${updatedPackages[n]}`)
       .join("\n");
   }
-  function major(versNum) {
-    if (typeof versNum === "string") {
-      return (
-        versNum.match(/^(?:workspace:)?[^\d]*(\d+)(?:\.|$)/)?.[1] ?? versNum
-      );
-    }
-    return versNum;
-  }
-
   let configPath = path.join(cwd, "upd.config.json");
   let newConfig;
   try {
@@ -355,52 +324,46 @@ export async function updateVersions({
   }
 
   let inventoryFailures = [];
-  let pathsPromise = await pReduce(
-    packagePaths,
-    async (mapReceived, currentPath) => {
-      let packagePath = path.join(cwd, currentPath);
-      let packContentsStr;
-      try {
-        packContentsStr = await readTextFile(packagePath, "utf8");
-      } catch (error) {
-        inventoryFailures.push(makeFailure("package read", currentPath, error));
-        return mapReceived;
-      }
+  let inventory = {
+    namesList: [],
+    pathsList: [],
+    pathsByName: {},
+    contentsObj: {},
+    contentsStr: {},
+  };
+  for (const currentPath of packagePaths) {
+    let packagePath = path.join(cwd, currentPath);
+    let packContentsStr;
+    try {
+      packContentsStr = await readTextFile(packagePath, "utf8");
+    } catch (error) {
+      inventoryFailures.push(makeFailure("package read", currentPath, error));
+      continue;
+    }
 
-      let parsedContents;
-      try {
-        parsedContents = JSON.parse(packContentsStr);
-        if (!isPlainObject(parsedContents)) {
-          throw new TypeError(
-            "update-versions/updateVersions(): [THROW_ID_08] package.json must contain a JSON object.",
-          );
-        }
-      } catch (error) {
-        inventoryFailures.push(
-          makeFailure("package parse", currentPath, error),
+    let parsedContents;
+    try {
+      parsedContents = JSON.parse(packContentsStr);
+      if (!isPlainObject(parsedContents)) {
+        throw new TypeError(
+          "update-versions/updateVersions(): [THROW_ID_08] package.json must contain a JSON object.",
         );
-        return mapReceived;
       }
+    } catch (error) {
+      inventoryFailures.push(makeFailure("package parse", currentPath, error));
+      continue;
+    }
 
-      mapReceived.namesList.push(parsedContents.name);
-      mapReceived.pathsList.push(currentPath);
-      mapReceived.pathsByName[parsedContents.name] = currentPath;
-      mapReceived.contentsStr[currentPath] = packContentsStr;
-      mapReceived.contentsObj[currentPath] = parsedContents;
-      return mapReceived;
-    },
-    {
-      namesList: [],
-      pathsList: [],
-      pathsByName: {},
-      contentsObj: {},
-      contentsStr: {},
-    },
-  );
+    inventory.namesList.push(parsedContents.name);
+    inventory.pathsList.push(currentPath);
+    inventory.pathsByName[parsedContents.name] = currentPath;
+    inventory.contentsStr[currentPath] = packContentsStr;
+    inventory.contentsObj[currentPath] = parsedContents;
+  }
 
   if (inventoryFailures.length > 0) {
     throw new UpdateVersionsError(inventoryFailures, {
-      unchangedFiles: pathsPromise.pathsList,
+      unchangedFiles: inventory.pathsList,
     });
   }
 
@@ -408,8 +371,8 @@ export async function updateVersions({
   // makes a failed registry run atomic from the caller's point of view and also
   // deduplicates lookups shared by packages in a monorepo.
   let externalNames = new Set();
-  for (let oneOfPaths of pathsPromise.pathsList) {
-    let parsedContents = pathsPromise.contentsObj[oneOfPaths];
+  for (let oneOfPaths of inventory.pathsList) {
+    let parsedContents = inventory.contentsObj[oneOfPaths];
     for (let dependencyKey of ["dependencies", "devDependencies"]) {
       if (isPlainObject(parsedContents[dependencyKey])) {
         for (let [name, spec] of Object.entries(
@@ -423,7 +386,7 @@ export async function updateVersions({
             let parsedSpec = parseDependencySpec(name, spec);
             if (
               parsedSpec.targetName &&
-              !pathsPromise.namesList.includes(parsedSpec.targetName)
+              !inventory.namesList.includes(parsedSpec.targetName)
             ) {
               externalNames.add(parsedSpec.targetName);
             }
@@ -464,7 +427,7 @@ export async function updateVersions({
 
   if (registryFailures.length > 0) {
     throw new UpdateVersionsError(registryFailures, {
-      unchangedFiles: pathsPromise.pathsList,
+      unchangedFiles: inventory.pathsList,
     });
   }
 
@@ -480,13 +443,13 @@ export async function updateVersions({
   }
 
   let allProgressPromise = PProgress.all(
-    pathsPromise.pathsList.map((oneOfPaths) =>
+    inventory.pathsList.map((oneOfPaths) =>
       pProgress(async (progress) => {
         // call progress() like progress(0.14);
 
         let amended = false;
-        let finalContents = pathsPromise.contentsStr[oneOfPaths];
-        let parsedContents = pathsPromise.contentsObj[oneOfPaths];
+        let finalContents = inventory.contentsStr[oneOfPaths];
+        let parsedContents = inventory.contentsObj[oneOfPaths];
         let fileUpdates = {};
 
         try {
@@ -527,10 +490,10 @@ export async function updateVersions({
               ? parsedContents.dependencies[singleDepName]
               : parsedContents.devDependencies[singleDepName];
             let parsedSpec = parseDependencySpec(singleDepName, singleDepValue);
-            if (pathsPromise.namesList.includes(parsedSpec.targetName)) {
+            if (inventory.namesList.includes(parsedSpec.targetName)) {
               let localVersion =
-                pathsPromise.contentsObj[
-                  pathsPromise.pathsByName[parsedSpec.targetName]
+                inventory.contentsObj[
+                  inventory.pathsByName[parsedSpec.targetName]
                 ].version;
               compiledDepNameVersionPairs[singleDepName] =
                 typeof localVersion === "string" && localVersion.length > 0
@@ -864,7 +827,7 @@ async function runCli() {
     moduleMode: Boolean(cli.flags.module),
     reportProgress: true,
   });
-  updateNotifier({ pkg }).notify();
+  notifyOfCliUpdate({ pkg });
 }
 
 function isDirectExecution() {

package/dependency-spec.js

@@ -0,0 +1,32 @@
+export function workspaceSpecPrefix(parsedSpec) {
+  return parsedSpec.kind === "workspace-alias"
+    ? `workspace:${parsedSpec.targetName}@`
+    : "workspace:";
+}
+
+export function updatedDependencySpec(parsedSpec, currentSpec, version) {
+  if (parsedSpec.kind === "registry") {
+    return `^${version}`;
+  }
+  if (parsedSpec.kind === "workspace-path") {
+    return currentSpec;
+  }
+
+  let workspaceRange = parsedSpec.selector;
+  if (["*", "^", "~"].includes(workspaceRange)) {
+    return currentSpec;
+  }
+  let firstVersionDigit = workspaceRange.search(/\d/);
+  if (firstVersionDigit === -1) {
+    return currentSpec;
+  }
+  let rangePrefix = workspaceRange.slice(0, firstVersionDigit);
+  return `${workspaceSpecPrefix(parsedSpec)}${rangePrefix}${version}`;
+}
+
+export function major(versNum) {
+  if (typeof versNum === "string") {
+    return versNum.match(/^(?:workspace:)?[^\d]*(\d+)(?:\.|$)/)?.[1] ?? versNum;
+  }
+  return versNum;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "update-versions",
-  "version": "7.2.3",
+  "version": "7.2.5",
   "description": "Like npm-check-updates but supports Lerna monorepos and enforces strict semver values",
   "keywords": [
     "app",
@@ -60,9 +60,12 @@
   },
   "c8": {
     "all": true,
+    "branches": 100,
     "check-coverage": true,
-    "exclude": ["**/test/**/*.*"],
-    "lines": 80
+    "exclude": ["**/test/**/*.*", "cli-update-notifier.js"],
+    "functions": 100,
+    "lines": 100,
+    "statements": 100
   },
   "lect": {
     "licence": {
@@ -71,17 +74,15 @@
   },
   "dependencies": {
     "ansi-diff-stream": "^1.2.1",
-    "codsen-glob": "^1.1.0",
-    "codsen-utils": "^1.10.0",
-    "edit-package-json": "^0.10.3",
+    "codsen-glob": "^1.1.2",
+    "codsen-utils": "^1.10.1",
+    "edit-package-json": "^0.10.5",
     "object-path": "^0.11.8",
     "p-progress": "^1.0.0",
-    "p-reduce": "^3.0.0",
-    "package-json": "^10.0.1",
-    "update-notifier": "^7.3.1"
+    "package-json": "^10.0.1"
   },
   "devDependencies": {
-    "p-map": "^7.0.4"
+    "p-map": "^7.0.7"
   },
   "engines": {
     "node": ">=18.20.8"