npm-pkg-lint 4.1.2 → 4.3.0

package/README.md

@@ -106,6 +106,7 @@ Verifies the presence of files specified in:
 - `browser`
 - `module`
 - `jsnext:main`,
+- `types`
 - `typings`
 - `bin`
 - `man`
@@ -116,6 +117,24 @@ Requires `types` to be the first condition in `exports`.
 
 **Why?** For TypeScript to properly detect `types` it need to come before `require` or `import`, else it will fall back to detecting by filename.
 
+## TypeScript `types` matching `exports`
+
+Requires `types` to match `exports`.
+
+**Why?** To avoid issues with newer TS versions resolving with `exports` if present rather than the older `types` field.
+
+## TypeScript prefer `types` over `typings`
+
+Requires `types` to be used instead of `typings`.
+
+**Why?** While TypeScript allows `typings` to be used as an alias, it is better for consistency to only use one over the other.
+
+## TypeScript conflicting `types` and `typings` fields
+
+Requires only one of the two fields `types` and `typings` to be used, not both.
+
+**Why?** `typings` is an alias for `types` and if both are set it is unclear which is to be used (and could potentially be set to different values).
+
 ## Disallowed dependencies
 
 Disallows certain packages from being included as `dependencies` (use `devDependencies` or `peerDependencies` instead).

package/dist/index.js

@@ -7511,6 +7511,7 @@ var git_default = regexp5;
 
 // src/blacklist/jest.ts
 var regexp6 = [
+  directory("__fixtures__"),
   directory("__snapshots__"),
   directory("__tests__"),
   extension(".snap"),
@@ -7532,7 +7533,8 @@ var regexp7 = [
   filename(".npmignore"),
   filename(".npmrc"),
   filename(".nvmrc"),
-  filename("lerna.json")
+  filename("lerna.json"),
+  filename("yarn.lock")
 ];
 var node_default = regexp7;
 
@@ -10487,12 +10489,12 @@ var Header = class {
     if (!buf || !(buf.length >= off + 512)) {
       throw new Error("need 512 bytes for header");
     }
-    this.path = decString(buf, off, 100);
-    this.mode = decNumber(buf, off + 100, 8);
-    this.uid = decNumber(buf, off + 108, 8);
-    this.gid = decNumber(buf, off + 116, 8);
-    this.size = decNumber(buf, off + 124, 12);
-    this.mtime = decDate(buf, off + 136, 12);
+    this.path = ex?.path ?? decString(buf, off, 100);
+    this.mode = ex?.mode ?? gex?.mode ?? decNumber(buf, off + 100, 8);
+    this.uid = ex?.uid ?? gex?.uid ?? decNumber(buf, off + 108, 8);
+    this.gid = ex?.gid ?? gex?.gid ?? decNumber(buf, off + 116, 8);
+    this.size = ex?.size ?? gex?.size ?? decNumber(buf, off + 124, 12);
+    this.mtime = ex?.mtime ?? gex?.mtime ?? decDate(buf, off + 136, 12);
     this.cksum = decNumber(buf, off + 148, 12);
     if (gex)
       this.#slurp(gex, true);
@@ -10510,10 +10512,10 @@ var Header = class {
     }
     this.linkpath = decString(buf, off + 157, 100);
     if (buf.subarray(off + 257, off + 265).toString() === "ustar\x0000") {
-      this.uname = decString(buf, off + 265, 32);
-      this.gname = decString(buf, off + 297, 32);
-      this.devmaj = decNumber(buf, off + 329, 8) ?? 0;
-      this.devmin = decNumber(buf, off + 337, 8) ?? 0;
+      this.uname = ex?.uname ?? gex?.uname ?? decString(buf, off + 265, 32);
+      this.gname = ex?.gname ?? gex?.gname ?? decString(buf, off + 297, 32);
+      this.devmaj = ex?.devmaj ?? gex?.devmaj ?? decNumber(buf, off + 329, 8) ?? 0;
+      this.devmin = ex?.devmin ?? gex?.devmin ?? decNumber(buf, off + 337, 8) ?? 0;
       if (buf[off + 475] !== 0) {
         const prefix2 = decString(buf, off + 345, 155);
         this.path = prefix2 + "/" + this.path;
@@ -10522,8 +10524,8 @@ var Header = class {
         if (prefix2) {
           this.path = prefix2 + "/" + this.path;
         }
-        this.atime = decDate(buf, off + 476, 12);
-        this.ctime = decDate(buf, off + 488, 12);
+        this.atime = ex?.atime ?? gex?.atime ?? decDate(buf, off + 476, 12);
+        this.ctime = ex?.ctime ?? gex?.ctime ?? decDate(buf, off + 488, 12);
       }
     }
     let sum = 8 * 32;
@@ -12330,13 +12332,15 @@ var listFileSync = (opt) => {
     const readSize = opt.maxReadSize || 16 * 1024 * 1024;
     if (stat.size < readSize) {
       const buf = Buffer.allocUnsafe(stat.size);
-      fs3.readSync(fd, buf, 0, stat.size, 0);
-      p.end(buf);
+      const read = fs3.readSync(fd, buf, 0, stat.size, 0);
+      p.end(read === buf.byteLength ? buf : buf.subarray(0, read));
     } else {
       let pos2 = 0;
       const buf = Buffer.allocUnsafe(readSize);
       while (pos2 < stat.size) {
         const bytesRead = fs3.readSync(fd, buf, 0, readSize, pos2);
+        if (bytesRead === 0)
+          break;
         pos2 += bytesRead;
         p.write(buf.subarray(0, bytesRead));
       }
@@ -15322,6 +15326,9 @@ function* requiredFiles(pkg) {
       ruleId
     });
   }
+  if (pkg.types) {
+    yield* yieldRequiredFiles(pkg.types, { field: "types", ruleId: "no-missing-types" });
+  }
   if (pkg.typings) {
     yield* yieldRequiredFiles(pkg.typings, { field: "typings", ruleId: "no-missing-typings" });
   }
@@ -15435,9 +15442,6 @@ async function persistentCacheSet(key, data) {
   await fs13.writeFile(filePath, content, "utf-8");
 }
 
-// src/rules/deprecated-dependency.ts
-var import_semver = __toESM(require_semver2(), 1);
-
 // src/utils/json-location.ts
 function findNextNode(current, segment, datapath) {
   const { value } = current;
@@ -15479,7 +15483,13 @@ import { stripVTControlCharacters } from "node:util";
 var getContext = (raw2) => ({
   start: process3.hrtime.bigint(),
   command: raw2.map((part) => getCommandPart(stripVTControlCharacters(part))).join(" "),
-  state: { stdout: "", stderr: "", output: "" }
+  state: {
+    stdout: "",
+    stderr: "",
+    output: "",
+    isIterating: {},
+    nonIterable: [false, false]
+  }
 });
 var getCommandPart = (part) => /[^\w./-]/.test(part) ? `'${part.replaceAll("'", "'\\''")}'` : part;
 
@@ -15637,8 +15647,8 @@ var concatenateShell = (file, commandArguments, options) => options.shell && com
 var bufferOutput = (stream, { state }, streamName) => {
   if (stream) {
     stream.setEncoding("utf8");
-    if (!state.isIterating) {
-      state.isIterating = false;
+    if (!state.isIterating[streamName]) {
+      state.isIterating[streamName] = false;
       stream.on("data", (chunk) => {
         state[streamName] += chunk;
         state.output += chunk;
@@ -15683,16 +15693,20 @@ var closeStdin = async (nodeChildProcess) => {
 
 // node_modules/nano-spawn/source/iterable.js
 import * as readline from "node:readline/promises";
-var lineIterator = async function* (subprocess, { state }, streamName) {
-  if (state.isIterating === false) {
+var lineIterator = async function* (subprocess, { state }, streamName, index) {
+  if (state.isIterating[streamName] === false) {
     throw new Error(`The subprocess must be iterated right away, for example:
 	for await (const line of spawn(...)) { ... }`);
   }
-  state.isIterating = true;
+  state.isIterating[streamName] = true;
   try {
     const { [streamName]: stream } = await subprocess.nodeChildProcess;
     if (!stream) {
-      return;
+      state.nonIterable[index] = true;
+      const message = state.nonIterable.every(Boolean) ? "either the option `stdout` or `stderr`" : `the option \`${streamName}\``;
+      throw new TypeError(
+        `The subprocess cannot be iterated unless ${message} is 'pipe'.`
+      );
     }
     handleErrors(subprocess);
     yield* readline.createInterface({ input: stream });
@@ -15706,11 +15720,11 @@ var handleErrors = async (subprocess) => {
   } catch {
   }
 };
-var combineAsyncIterators = async function* (...iterators) {
+var combineAsyncIterators = async function* ({ state }, ...iterators) {
   try {
     let promises = [];
     while (iterators.length > 0) {
-      promises = iterators.map((iterator2, index2) => promises[index2] ?? getNext(iterator2));
+      promises = iterators.map((iterator2, index2) => promises[index2] ?? getNext(iterator2, index2, state));
       const [{ value, done }, index] = await Promise.race(promises.map((promise, index2) => Promise.all([promise, index2])));
       const [iterator] = iterators.splice(index, 1);
       promises.splice(index, 1);
@@ -15723,13 +15737,14 @@ var combineAsyncIterators = async function* (...iterators) {
     await Promise.all(iterators.map((iterator) => iterator.return()));
   }
 };
-var getNext = async (iterator) => {
+var getNext = async (iterator, index, { nonIterable }) => {
   try {
     return await iterator.next();
   } catch (error) {
-    await iterator.throw(error);
+    return shouldIgnoreError(nonIterable, index) ? iterator.return() : iterator.throw(error);
   }
 };
+var shouldIgnoreError = (nonIterable, index) => nonIterable.every(Boolean) ? index !== nonIterable.length - 1 : nonIterable[index];
 
 // node_modules/nano-spawn/source/index.js
 function spawn2(file, second, third, previous) {
@@ -15740,13 +15755,13 @@ function spawn2(file, second, third, previous) {
   let subprocess = getResult(nodeChildProcess, spawnOptions, context);
   Object.assign(subprocess, { nodeChildProcess });
   subprocess = previous ? handlePipe([previous, subprocess]) : subprocess;
-  const stdout = lineIterator(subprocess, context, "stdout");
-  const stderr = lineIterator(subprocess, context, "stderr");
+  const stdout = lineIterator(subprocess, context, "stdout", 0);
+  const stderr = lineIterator(subprocess, context, "stderr", 1);
   return Object.assign(subprocess, {
     nodeChildProcess,
     stdout,
     stderr,
-    [Symbol.asyncIterator]: () => combineAsyncIterators(stdout, stderr),
+    [Symbol.asyncIterator]: () => combineAsyncIterators(context, stdout, stderr),
     pipe: (file2, second2, third2) => spawn2(file2, second2, third2, subprocess)
   });
 }
@@ -15807,8 +15822,26 @@ async function npmInfo(pkg, options = { ignoreUnpublished: false }) {
   }
 }
 
+// src/rules/conflicting-types-typings.ts
+var ruleId2 = "conflicting-types-typings";
+var severity = Severity.ERROR;
+function* conflictingTypesTypings(pkg, pkgAst) {
+  if (!pkg.types || !pkg.typings) {
+    return;
+  }
+  const { line, column } = jsonLocation(pkgAst, "member", "typings");
+  yield {
+    ruleId: ruleId2,
+    severity,
+    message: `Duplicate "typings" and "types" field`,
+    line,
+    column
+  };
+}
+
 // src/rules/deprecated-dependency.ts
-var ruleId2 = "no-deprecated-dependency";
+var import_semver = __toESM(require_semver2(), 1);
+var ruleId3 = "no-deprecated-dependency";
 function createEntry(key, version2, source) {
   if (version2.startsWith("file:")) {
     return null;
@@ -15864,7 +15897,7 @@ async function deprecatedDependency(pkg, pkgAst, options) {
       }
       const { line, column } = jsonLocation(pkgAst, "member", dependency.source, dependency.name);
       messages.push({
-        ruleId: ruleId2,
+        ruleId: ruleId3,
         severity: 2,
         message: `"${dependency.spec}" is deprecated and must not be used`,
         line,
@@ -15877,7 +15910,7 @@ async function deprecatedDependency(pkg, pkgAst, options) {
         }
         const { line, column } = jsonLocation(pkgAst, "member", dependency.source, dependency.name);
         messages.push({
-          ruleId: ruleId2,
+          ruleId: ruleId3,
           severity: 1,
           message: `"${dependency.spec}" is not published to the NPM registry`,
           line,
@@ -15977,8 +16010,8 @@ function isDisallowedDependency(pkg, dependency) {
 }
 
 // src/rules/exports-types-order.ts
-var ruleId3 = "exports-types-order";
-var severity = Severity.ERROR;
+var ruleId4 = "exports-types-order";
+var severity2 = Severity.ERROR;
 function* validateOrder(pkgAst, value, path15) {
   if (!value || typeof value === "string") {
     return;
@@ -15991,8 +16024,8 @@ function* validateOrder(pkgAst, value, path15) {
     const { line, column } = jsonLocation(pkgAst, "member", "exports", ...path15, "types");
     const property = path15.map((it) => `["${it}"]`).join("");
     yield {
-      ruleId: ruleId3,
-      severity,
+      ruleId: ruleId4,
+      severity: severity2,
       message: `"types" must be the first condition in "exports${property}"`,
       line,
       column
@@ -16048,14 +16081,14 @@ var nodeVersions = [
 ];
 
 // src/rules/outdated-engines.ts
-var ruleId4 = "outdated-engines";
-var severity2 = Severity.ERROR;
+var ruleId5 = "outdated-engines";
+var severity3 = Severity.ERROR;
 function* outdatedEngines(pkg, pkgAst, ignoreNodeVersion) {
   if (!pkg.engines?.node) {
     const { line: line2, column: column2 } = pkg.engines ? jsonLocation(pkgAst, "member", "engines") : { line: 1, column: 1 };
     yield {
-      ruleId: ruleId4,
-      severity: severity2,
+      ruleId: ruleId5,
+      severity: severity3,
       message: "Missing engines.node field",
       line: line2,
       column: column2
@@ -16066,8 +16099,8 @@ function* outdatedEngines(pkg, pkgAst, ignoreNodeVersion) {
   const range = pkg.engines.node;
   if (!import_semver2.default.validRange(range)) {
     yield {
-      ruleId: ruleId4,
-      severity: severity2,
+      ruleId: ruleId5,
+      severity: severity3,
       message: `engines.node "${range}" is not a valid semver range`,
       line,
       column
@@ -16093,8 +16126,8 @@ function* outdatedEngines(pkg, pkgAst, ignoreNodeVersion) {
     const nodeRelease = major > 0 ? major : `0.${String(minor)}`;
     const message = `engines.node is satisfied by Node ${String(nodeRelease)} (EOL since ${descriptor.eol})`;
     yield {
-      ruleId: ruleId4,
-      severity: severity2,
+      ruleId: ruleId5,
+      severity: severity3,
       message,
       line,
       column
@@ -16106,8 +16139,8 @@ function* outdatedEngines(pkg, pkgAst, ignoreNodeVersion) {
     const version2 = `v${String(ignoreNodeVersion)}.x`;
     const message = `--ignore-node-version=${option} used but engines.node="${range}" does not match ${version2} or the version is not EOL yet`;
     yield {
-      ruleId: ruleId4,
-      severity: severity2,
+      ruleId: ruleId5,
+      severity: severity3,
       message,
       line,
       column
@@ -16115,10 +16148,75 @@ function* outdatedEngines(pkg, pkgAst, ignoreNodeVersion) {
   }
 }
 
+// src/rules/prefer-types.ts
+var ruleId6 = "prefer-types";
+var severity4 = Severity.ERROR;
+function* preferTypes(pkg, pkgAst) {
+  if (!pkg.typings || pkg.types) {
+    return;
+  }
+  const { line, column } = jsonLocation(pkgAst, "member", "typings");
+  yield {
+    ruleId: ruleId6,
+    severity: severity4,
+    message: `Prefer "types" over "typings"`,
+    line,
+    column
+  };
+}
+
+// src/rules/shadowed-types.ts
+var ruleId7 = "shadowed-types";
+var severity5 = Severity.ERROR;
+function findDotTypes(exports) {
+  if (typeof exports === "string") {
+    return null;
+  }
+  const dot = exports["."];
+  if (!dot || typeof dot === "string") {
+    return null;
+  }
+  const types2 = dot.types;
+  if (typeof types2 === "string") {
+    return types2;
+  } else {
+    return null;
+  }
+}
+function* validateTypeSubpath(pkgAst, subpath, field, value) {
+  if (value.startsWith("./") && subpath === value) {
+    return;
+  }
+  if (subpath === `./${value}`) {
+    return;
+  }
+  const { line, column } = jsonLocation(pkgAst, "member", field);
+  yield {
+    ruleId: ruleId7,
+    severity: severity5,
+    message: `"${field}" cannot be resolved when respecting "exports" field`,
+    line,
+    column
+  };
+}
+function* shadowedTypes(pkg, pkgAst) {
+  const { exports } = pkg;
+  if (!exports) {
+    return;
+  }
+  const subpath = findDotTypes(exports);
+  if (pkg.types) {
+    yield* validateTypeSubpath(pkgAst, subpath, "types", pkg.types);
+  }
+  if (pkg.typings) {
+    yield* validateTypeSubpath(pkgAst, subpath, "typings", pkg.typings);
+  }
+}
+
 // src/rules/types-node-matching-engine.ts
 var import_semver3 = __toESM(require_semver2(), 1);
-var ruleId5 = "types-node-matching-engine";
-var severity3 = Severity.ERROR;
+var ruleId8 = "types-node-matching-engine";
+var severity6 = Severity.ERROR;
 function* typesNodeMatchingEngine(pkg, pkgAst) {
   if (!pkg.engines?.node) {
     return;
@@ -16142,8 +16240,8 @@ function* typesNodeMatchingEngine(pkg, pkgAst) {
       const actualVersion = `v${String(typesVersion.major)}`;
       const expectedVersion = `v${String(nodeVersion.major)}`;
       yield {
-        ruleId: ruleId5,
-        severity: severity3,
+        ruleId: ruleId8,
+        severity: severity6,
         message: `@types/node ${actualVersion} does not equal engines.node ${expectedVersion}`,
         line,
         column
@@ -16154,7 +16252,7 @@ function* typesNodeMatchingEngine(pkg, pkgAst) {
 
 // src/rules/verify-engine-constraint.ts
 var import_semver4 = __toESM(require_semver2(), 1);
-var ruleId6 = "invalid-engine-constraint";
+var ruleId9 = "invalid-engine-constraint";
 async function* getDeepDependencies(pkg, visited, dependency) {
   if (dependency) {
     if (visited.has(dependency)) {
@@ -16192,7 +16290,7 @@ async function verifyDependency(dependency, minDeclared, declaredConstraint) {
   }
   if (!import_semver4.default.satisfies(minDeclared, constraint)) {
     return {
-      ruleId: ruleId6,
+      ruleId: ruleId9,
       severity: 2,
       message: `the transitive dependency "${dependency}" (node ${constraint}) does not satisfy the declared node engine "${declaredConstraint}"`,
       line: 1,
@@ -16221,7 +16319,7 @@ async function verifyEngineConstraint(pkg) {
     } catch (err) {
       if (isNpmInfoError(err) && err.code === "E404") {
         messages.push({
-          ruleId: ruleId6,
+          ruleId: ruleId9,
           severity: 1,
           message: `the transitive dependency "${dependency}" is not published to the NPM registry`,
           line: 1,
@@ -16476,12 +16574,15 @@ function verifyDependencies(pkg, pkgAst, options) {
 async function verifyPackageJson(pkg, pkgAst, filePath, options = { allowedDependencies: /* @__PURE__ */ new Set(), ignoreNodeVersion: false }) {
   const { ignoreNodeVersion } = options;
   const messages = [
+    ...conflictingTypesTypings(pkg, pkgAst),
     ...await deprecatedDependency(pkg, pkgAst, options),
     ...await verifyEngineConstraint(pkg),
     ...exportsTypesOrder(pkg, pkgAst),
     ...verifyFields(pkg, pkgAst, options),
     ...verifyDependencies(pkg, pkgAst, options),
     ...outdatedEngines(pkg, pkgAst, ignoreNodeVersion),
+    ...preferTypes(pkg, pkgAst),
+    ...shadowedTypes(pkg, pkgAst),
     ...typesNodeMatchingEngine(pkg, pkgAst)
   ];
   if (messages.length === 0) {