npm-pkg-lint 4.1.2 → 4.2.0

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;
 
@@ -15479,7 +15481,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 +15645,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 +15691,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 +15718,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 +15735,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 +15753,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)
   });
 }