npm-pkg-lint 3.0.0 → 3.1.0

package/dist/index.js

@@ -12514,8 +12514,11 @@ var require_re = __commonJS({
     createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
     createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
     createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
-    createToken("COERCE", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:$|[^\\d])`);
+    createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+    createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+    createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
     createToken("COERCERTL", src[t.COERCE], true);
+    createToken("COERCERTLFULL", src[t.COERCEFULL], true);
     createToken("LONETILDE", "(?:~>?)");
     createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
     exports.tildeTrimReplace = "$1~";
@@ -13150,21 +13153,27 @@ var require_coerce = __commonJS({
       options = options || {};
       let match2 = null;
       if (!options.rtl) {
-        match2 = version2.match(re[t.COERCE]);
+        match2 = version2.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
       } else {
+        const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
         let next;
-        while ((next = re[t.COERCERTL].exec(version2)) && (!match2 || match2.index + match2[0].length !== version2.length)) {
+        while ((next = coerceRtlRegex.exec(version2)) && (!match2 || match2.index + match2[0].length !== version2.length)) {
           if (!match2 || next.index + next[0].length !== match2.index + match2[0].length) {
             match2 = next;
           }
-          re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
+          coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
         }
-        re[t.COERCERTL].lastIndex = -1;
+        coerceRtlRegex.lastIndex = -1;
       }
       if (match2 === null) {
         return null;
       }
-      return parse(`${match2[2]}.${match2[3] || "0"}.${match2[4] || "0"}`, options);
+      const major = match2[2];
+      const minor = match2[3] || "0";
+      const patch = match2[4] || "0";
+      const prerelease = options.includePrerelease && match2[5] ? `-${match2[5]}` : "";
+      const build = options.includePrerelease && match2[6] ? `+${match2[6]}` : "";
+      return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options);
     };
     module.exports = coerce;
   }
@@ -15010,7 +15019,6 @@ import { fileURLToPath as fileURLToPath3 } from "url";
 
 // node_modules/find-up/index.js
 import path2 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
 
 // node_modules/find-up/node_modules/locate-path/index.js
 import process2 from "process";
@@ -15190,14 +15198,19 @@ async function locatePath(paths, {
   }, { concurrency, preserveOrder });
 }
 
+// node_modules/unicorn-magic/node.js
+import { fileURLToPath as fileURLToPath2 } from "url";
+function toPath2(urlOrPath) {
+  return urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath;
+}
+
 // node_modules/find-up/index.js
-var toPath2 = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath;
 var findUpStop = Symbol("findUpStop");
 async function findUpMultiple(name, options = {}) {
-  let directory2 = path2.resolve(toPath2(options.cwd) || "");
+  let directory2 = path2.resolve(toPath2(options.cwd) ?? "");
   const { root } = path2.parse(directory2);
-  const stopAt = path2.resolve(directory2, options.stopAt || root);
-  const limit = options.limit || Number.POSITIVE_INFINITY;
+  const stopAt = path2.resolve(directory2, toPath2(options.stopAt ?? root));
+  const limit = options.limit ?? Number.POSITIVE_INFINITY;
   const paths = [name].flat();
   const runMatcher = async (locateOptions) => {
     if (typeof name !== "function") {
@@ -15874,8 +15887,8 @@ async function verifyTarball(pkg, tarball) {
     {
       messages,
       filePath: tarball.reportPath ?? tarball.filePath,
-      errorCount: messages.length,
-      warningCount: 0,
+      errorCount: messages.filter((it) => it.severity === 2).length,
+      warningCount: messages.filter((it) => it.severity === 1).length,
       fixableErrorCount: 0,
       fixableWarningCount: 0
     }
@@ -15884,6 +15897,7 @@ async function verifyTarball(pkg, tarball) {
 
 // src/validators/validation-error.ts
 var ValidationError = class extends Error {
+  validator;
   constructor(validator, message) {
     super(message);
     this.validator = validator;
@@ -17649,20 +17663,58 @@ async function persistentCacheSet(key, data) {
 
 // src/utils/npm-info.ts
 var cache = /* @__PURE__ */ new Map();
-async function npmInfo(pkg) {
+function isExecaError(error) {
+  return Boolean(error && error instanceof Error && "stdout" in error);
+}
+function isNpmInfoError(error) {
+  return Boolean(error && error instanceof Error && "summary" in error);
+}
+function tryParse(maybeJson) {
+  try {
+    return JSON.parse(maybeJson);
+  } catch {
+    return null;
+  }
+}
+async function npmInfo(pkg, options = { ignoreUnpublished: false }) {
+  const { ignoreUnpublished } = options;
   const cached = cache.get(pkg);
-  if (cached) {
+  if (cached === null) {
+    if (ignoreUnpublished) {
+      return null;
+    }
+  } else if (cached) {
     return cached;
   }
   const persistent = await persistentCacheGet(pkg);
   if (persistent) {
     return persistent;
   }
-  const result = await execa("npm", ["info", "--json", pkg]);
-  const pkgData = JSON.parse(result.stdout);
-  cache.set(pkg, pkgData);
-  await persistentCacheSet(pkg, pkgData);
-  return pkgData;
+  try {
+    const result = await execa("npm", ["info", "--json", pkg]);
+    const pkgData = JSON.parse(result.stdout);
+    cache.set(pkg, pkgData);
+    await persistentCacheSet(pkg, pkgData);
+    return pkgData;
+  } catch (err) {
+    if (!isExecaError(err)) {
+      throw err;
+    }
+    const parsed = tryParse(err.stdout);
+    if (!parsed) {
+      throw err;
+    }
+    const { code, summary, detail } = parsed.error;
+    cache.set(pkg, null);
+    if (ignoreUnpublished && code === "E404") {
+      return null;
+    }
+    const wrappedError = new Error(summary, { cause: err });
+    wrappedError.code = code;
+    wrappedError.summary = summary;
+    wrappedError.detail = detail;
+    throw wrappedError;
+  }
 }
 
 // src/rules/deprecated-dependency.ts
@@ -17681,17 +17733,31 @@ function* getDependencies(pkg) {
 async function deprecatedDependency(pkg) {
   const messages = [];
   for await (const dependency of getDependencies(pkg)) {
-    const { deprecated } = await npmInfo(dependency);
-    if (!deprecated) {
-      continue;
+    try {
+      const { deprecated } = await npmInfo(dependency);
+      if (!deprecated) {
+        continue;
+      }
+      messages.push({
+        ruleId: ruleId2,
+        severity: 2,
+        message: `"${dependency}" is deprecated and must not be used`,
+        line: 1,
+        column: 1
+      });
+    } catch (err) {
+      if (isNpmInfoError(err) && err.code === "E404") {
+        messages.push({
+          ruleId: ruleId2,
+          severity: 1,
+          message: `the dependency "${dependency}" is not published to the NPM registry`,
+          line: 1,
+          column: 1
+        });
+        continue;
+      }
+      throw err;
     }
-    messages.push({
-      ruleId: ruleId2,
-      severity: 2,
-      message: `"${dependency}" is deprecated and must not be used`,
-      line: 1,
-      column: 1
-    });
   }
   return messages;
 }
@@ -17885,7 +17951,10 @@ function* outdatedEngines(pkg) {
 var import_semver3 = __toESM(require_semver2(), 1);
 var ruleId5 = "invalid-engine-constraint";
 async function* getDeepDependencies(pkg, dependency) {
-  const pkgData = dependency ? await npmInfo(dependency) : pkg;
+  const pkgData = dependency ? await npmInfo(dependency, { ignoreUnpublished: true }) : pkg;
+  if (!pkgData) {
+    return;
+  }
   for (const [key, version2] of Object.entries(pkgData.dependencies ?? {})) {
     if (key === "@types/node") {
       continue;
@@ -17896,8 +17965,26 @@ async function* getDeepDependencies(pkg, dependency) {
     yield* getDeepDependencies(pkg, deep);
   }
 }
+async function verifyDependency(dependency, minDeclared, declaredConstraint) {
+  var _a;
+  const pkgData = await npmInfo(dependency);
+  const constraint = (_a = pkgData.engines) == null ? void 0 : _a.node;
+  if (!constraint) {
+    return null;
+  }
+  if (!import_semver3.default.satisfies(minDeclared, constraint)) {
+    return {
+      ruleId: ruleId5,
+      severity: 2,
+      message: `the transitive dependency "${dependency}" (node ${constraint}) does not satisfy the declared node engine "${declaredConstraint}"`,
+      line: 1,
+      column: 1
+    };
+  }
+  return null;
+}
 async function verifyEngineConstraint(pkg) {
-  var _a, _b;
+  var _a;
   const declaredConstraint = (_a = pkg.engines) == null ? void 0 : _a.node;
   if (!declaredConstraint) {
     return [];
@@ -17907,20 +17994,29 @@ async function verifyEngineConstraint(pkg) {
     throw new Error(`Failed to parse engine constraint "${declaredConstraint}"`);
   }
   const messages = [];
+  const visited = /* @__PURE__ */ new Set();
   for await (const dependency of getDeepDependencies(pkg)) {
-    const pkgData = await npmInfo(dependency);
-    const constraint = (_b = pkgData.engines) == null ? void 0 : _b.node;
-    if (!constraint) {
+    if (visited.has(dependency)) {
       continue;
     }
-    if (!import_semver3.default.satisfies(minDeclared, constraint)) {
-      messages.push({
-        ruleId: ruleId5,
-        severity: 2,
-        message: `the transitive dependency "${dependency}" (node ${constraint}) does not satisfy the declared node engine "${declaredConstraint}"`,
-        line: 1,
-        column: 1
-      });
+    visited.add(dependency);
+    try {
+      const message = await verifyDependency(dependency, minDeclared, declaredConstraint);
+      if (message) {
+        messages.push(message);
+      }
+    } catch (err) {
+      if (isNpmInfoError(err) && err.code === "E404") {
+        messages.push({
+          ruleId: ruleId5,
+          severity: 1,
+          message: `the transitive dependency "${dependency}" is not published to the NPM registry`,
+          line: 1,
+          column: 1
+        });
+        continue;
+      }
+      throw err;
     }
   }
   return messages;
@@ -18048,8 +18144,8 @@ async function verifyPackageJson(pkg, filePath, options = {}) {
     {
       messages,
       filePath,
-      errorCount: messages.length,
-      warningCount: 0,
+      errorCount: messages.filter((it) => it.severity === 2).length,
+      warningCount: messages.filter((it) => it.severity === 1).length,
       fixableErrorCount: 0,
       fixableWarningCount: 0
     }