knip 6.34.0 → 6.35.1

package/dist/binaries/bash-parser.js

@@ -1,16 +1,11 @@
 import { parse } from 'unbash';
-import { Plugins, pluginArgsMap } from '../plugins.js';
 import { debugLogObject } from '../util/debug.js';
-import { toBinary, toDeferResolve } from '../util/input.js';
 import { extractBinary, isValidBinary } from '../util/modules.js';
 import { relative } from '../util/path.js';
 import { substringBefore, truncate } from '../util/string.js';
 import { walkCommands } from '../util/scripts.js';
-import { resolve as fallbackResolve } from './fallback.js';
-import KnownResolvers from './resolvers/index.js';
-import { resolve as resolverFromPlugins } from './plugins.js';
-import { parseNodeArgs } from './util.js';
-const spawningBinaries = ['cross-env', 'retry-cli'];
+import { getDependenciesFromCommand } from './command.js';
+import { toScript } from './util.js';
 const collectExpansionScripts = (word, out) => {
     if (!word.parts)
         return;
@@ -35,21 +30,19 @@ export const getDependenciesFromScript = (script, options) => {
         const first = typeof args[0] === 'string' ? args[0] : args[0].value;
         if (!isValidBinary(substringBefore(first, ' ')))
             return [];
-        const parts = [];
-        for (const arg of args) {
-            if (typeof arg === 'string') {
-                if (arg !== '--')
-                    parts.push(arg);
-            }
-            else if (arg.value !== '--')
-                parts.push(arg.text);
-        }
-        return getDependenciesFromScript(parts.join(' '), {
+        return getDependenciesFromScript(toScript(args), {
             ...options,
             knownBinsOnly: false,
             ...opts,
         });
     };
+    const fromWords = (words, opts) => {
+        const script = words
+            .filter(word => word.text !== '--')
+            .map(word => word.text)
+            .join(' ');
+        return getDependenciesFromScript(script, opts);
+    };
     const definedFunctions = new Set();
     const collectFunctionNames = (statements) => {
         for (const stmt of statements)
@@ -68,8 +61,6 @@ export const getDependenciesFromScript = (script, options) => {
         return [...mainDeps, ...expansionDeps];
     };
     const processCommand = (node, pending) => {
-        const text = node.name?.value;
-        const binary = text ? extractBinary(text) : text;
         if (node.name)
             collectExpansionScripts(node.name, pending);
         for (const prefix of node.prefix)
@@ -77,46 +68,9 @@ export const getDependenciesFromScript = (script, options) => {
                 collectExpansionScripts(prefix.value, pending);
         for (const suffix of node.suffix)
             collectExpansionScripts(suffix, pending);
-        if (!binary || binary === '.' || binary === 'source' || binary === '[')
-            return [];
-        if (binary.startsWith('-') || binary.startsWith('..'))
-            return [];
-        if (definedFunctions.has(binary))
-            return [];
-        const words = node.suffix;
-        if (binary === '!' || binary === 'test')
-            return fromArgs(words);
-        const fromNodeOptions = node.prefix
-            .filter(a => a.name === 'NODE_OPTIONS' && a.value)
-            .map(a => a.value.value)
-            .map(arg => parseNodeArgs(arg.split(' ')))
-            .filter(args => args.require)
-            .flatMap(arg => arg.require)
-            .map(id => toDeferResolve(id));
-        if (binary in KnownResolvers) {
-            const resolver = KnownResolvers[binary];
-            return resolver(binary, words, { ...options, fromArgs });
-        }
-        if (pluginArgsMap.has(binary)) {
-            return [...resolverFromPlugins(binary, words, { ...options, fromArgs }), ...fromNodeOptions];
-        }
-        if (spawningBinaries.includes(binary)) {
-            const rest = node.suffix
-                .filter(w => w.text !== '--')
-                .map(w => w.text)
-                .join(' ');
-            return [toBinary(binary), ...getDependenciesFromScript(rest, options)];
-        }
-        if (binary in Plugins) {
-            const inputs = fallbackResolve(binary, words, { ...options, fromArgs });
-            if (options.knownBinsOnly)
-                for (const input of inputs)
-                    input.optional = true;
-            return [...inputs, ...fromNodeOptions];
-        }
-        if (options.knownBinsOnly && !text?.startsWith('.'))
+        if (definedFunctions.size && node.name && definedFunctions.has(extractBinary(node.name.value)))
             return [];
-        return [...fallbackResolve(binary, words, { ...options, fromArgs }), ...fromNodeOptions];
+        return getDependenciesFromCommand(node, { ...options, fromArgs }, fromWords);
     };
     try {
         const parsed = parse(script);

package/dist/binaries/command.d.ts

@@ -0,0 +1,5 @@
+import type { Command, Word } from 'unbash';
+import type { BinaryResolverOptions, GetInputsFromScriptsOptions } from '../types/config.ts';
+import { type Input } from '../util/input.ts';
+export declare const getInputsFromNodeOptions: (prefix: Command['prefix']) => Input[];
+export declare const getDependenciesFromCommand: (node: Command, options: BinaryResolverOptions, fromWords?: (words: Word[], options: GetInputsFromScriptsOptions) => Input[]) => Input[];

package/dist/binaries/command.js

@@ -0,0 +1,47 @@
+import { Plugins, pluginArgsMap } from '../plugins.js';
+import { toBinary, toDeferResolve } from '../util/input.js';
+import { extractBinary } from '../util/modules.js';
+import { resolve as fallbackResolve, spawningBinaries } from './fallback.js';
+import KnownResolvers from './resolvers/index.js';
+import { resolve as resolverFromPlugins } from './plugins.js';
+import { parseNodeArgs } from './util.js';
+export const getInputsFromNodeOptions = (prefix) => prefix
+    .filter(a => a.name === 'NODE_OPTIONS' && a.value)
+    .map(a => a.value.value)
+    .map(arg => parseNodeArgs(arg.split(' ')))
+    .filter(args => args.require)
+    .flatMap(arg => arg.require)
+    .map(id => toDeferResolve(id));
+export const getDependenciesFromCommand = (node, options, fromWords = options.fromArgs) => {
+    const text = node.name?.value;
+    const binary = text ? extractBinary(text) : text;
+    const { fromArgs } = options;
+    if (!binary || binary === '.' || binary === 'source' || binary === '[')
+        return [];
+    if (binary.startsWith('-') || binary.startsWith('..'))
+        return [];
+    const words = node.suffix;
+    if (binary === '!' || binary === 'test')
+        return fromArgs(words);
+    const fromNodeOptions = getInputsFromNodeOptions(node.prefix);
+    if (binary in KnownResolvers) {
+        const resolver = KnownResolvers[binary];
+        return resolver(binary, words, options);
+    }
+    if (pluginArgsMap.has(binary)) {
+        return [...resolverFromPlugins(binary, words, options), ...fromNodeOptions];
+    }
+    if (spawningBinaries.includes(binary)) {
+        return [toBinary(binary), ...fromWords(words, options)];
+    }
+    if (binary in Plugins) {
+        const inputs = fallbackResolve(binary, words, options);
+        if (options.knownBinsOnly)
+            for (const input of inputs)
+                input.optional = true;
+        return [...inputs, ...fromNodeOptions];
+    }
+    if (options.knownBinsOnly && !text?.startsWith('.'))
+        return [];
+    return [...fallbackResolve(binary, words, options), ...fromNodeOptions];
+};

package/dist/binaries/fallback.d.ts

@@ -1,2 +1,4 @@
 import type { BinaryResolver } from '../types/config.ts';
+export declare const spawningBinaries: string[];
+export declare const isWrapper: (binary: string) => boolean;
 export declare const resolve: BinaryResolver;

package/dist/binaries/fallback.js

@@ -4,9 +4,11 @@ import { toBinary, toDeferResolve, toEntry } from '../util/input.js';
 import { isValidBinary } from '../util/modules.js';
 import { isAbsolute } from '../util/path.js';
 import { argsAfter } from './util.js';
+export const spawningBinaries = ['cross-env', 'retry-cli'];
 const endOfCommandBinaries = ['dotenvx', 'env-cmd', 'op'];
 const positionals = new Set(['babel-node', 'esbuild', 'execa', 'jiti', 'oxnode', 'vite-node', 'zx']);
 const positionalBinaries = new Set(['concurrently']);
+export const isWrapper = (binary) => spawningBinaries.includes(binary) || endOfCommandBinaries.includes(binary) || positionalBinaries.has(binary);
 export const resolve = (binary, words, { fromArgs }) => {
     const parsed = parseArgs(words, { boolean: ['quiet', 'verbose'], '--': endOfCommandBinaries.includes(binary) });
     const bin = binary.startsWith('.') || (binary.includes('/') && !isAbsolute(binary))

package/dist/binaries/plugins.d.ts

@@ -1,2 +1,3 @@
 import type { BinaryResolver } from '../types/config.ts';
+export declare const isWrapper: (binary: string) => boolean;
 export declare const resolve: BinaryResolver;

package/dist/binaries/plugins.js

@@ -4,11 +4,12 @@ import { compact } from '../util/array.js';
 import { toBinary, toConfig, toDeferResolve, toDeferResolveEntry, toEntry } from '../util/input.js';
 import { extractBinary } from '../util/modules.js';
 import { dirname } from '../util/path.js';
-import { resolve as fallbackResolve } from './fallback.js';
+import { isWrapper as isFallbackWrapper, resolve as fallbackResolve } from './fallback.js';
 import { toWordArgs } from './util.js';
 const isGlobLikeMatch = /(^!|[*+\\(|{^$])/;
 const isGlobLike = (value) => isGlobLikeMatch.test(value);
 const nodeLoadersArgs = { import: ['r', 'experimental-loader', 'require', 'loader'] };
+export const isWrapper = (binary) => !!pluginArgsMap.get(binary)?.[1].fromArgs || isFallbackWrapper(binary);
 export const resolve = (binary, words, options) => {
     const { cwd, fromArgs, containingFilePath, manifest } = options;
     const [pluginName, pluginArgs] = pluginArgsMap.get(binary) ?? [];

package/dist/binaries/resolvers/pnpm.js

@@ -70,6 +70,7 @@ const commands = [
     'self-update',
     'server',
     'setup',
+    'stage',
     'start',
     'store',
     't',

package/dist/binaries/util.d.ts

@@ -1,6 +1,7 @@
 import type { Word } from 'unbash';
 import type { BinaryResolverOptions, GetInputsFromScriptsOptions, ScriptArg } from '../types/config.ts';
 import type { Input } from '../util/input.ts';
+export declare const toScript: (args: ScriptArg[]) => string;
 export declare const argsFrom: <T extends string | Word>(args: readonly T[], from: string) => T[];
 export declare const argsAfter: <T extends string | Word>(args: readonly T[], token: string) => T[];
 export declare const toWordArgs: (values: (string | number)[], words: Word[]) => ScriptArg[];

package/dist/binaries/util.js

@@ -1,5 +1,17 @@
 import parseArgs from '../util/parse-args.js';
 const valueOf = (arg) => (typeof arg === 'string' ? arg : arg.value);
+export const toScript = (args) => {
+    const parts = [];
+    for (const arg of args) {
+        if (typeof arg === 'string') {
+            if (arg !== '--')
+                parts.push(arg);
+        }
+        else if (arg.value !== '--')
+            parts.push(arg.text);
+    }
+    return parts.join(' ');
+};
 export const argsFrom = (args, from) => args.slice(args.findIndex(arg => valueOf(arg) === from));
 export const argsAfter = (args, token) => {
     const index = args.findIndex(arg => valueOf(arg) === token);

package/dist/cli.js

@@ -5,7 +5,8 @@ import { createOptions } from './util/create-options.js';
 import { getKnownErrors, hasErrorCause, isConfigurationError, isKnownError, isLoaderError, isModuleNotFoundError, } from './util/errors.js';
 import { logError } from './util/log.js';
 import { perfObserver } from './util/Performance.js';
-import { runPreprocessors, runReporters } from './util/reporter.js';
+import { createPreprocessor, toReporterOptions } from './util/preprocessor.js';
+import { runReporters } from './util/reporter.js';
 import { prettyMilliseconds } from './util/string.js';
 import { version } from './version.js';
 let args = {};
@@ -32,31 +33,10 @@ const main = async () => {
         }
         const options = await createOptions({ args });
         const { results } = await run(options);
-        const { issues, counters, tagHints, configurationHints, includedWorkspaceDirs, enabledPlugins, selectedWorkspaces, } = results;
         if (options.isWatch || options.isTrace)
             return;
-        const initialData = {
-            report: options.includedIssueTypes,
-            issues,
-            counters,
-            tagHints,
-            configurationHints,
-            enabledPlugins,
-            includedWorkspaceDirs,
-            cwd: options.cwd,
-            configFilePath: options.configFilePath,
-            isDisableConfigHints: options.isDisableConfigHints,
-            isDisableTagHints: options.isDisableTagHints,
-            isProduction: options.isProduction,
-            isShowProgress: options.isShowProgress,
-            isTreatConfigHintsAsErrors: options.isTreatConfigHintsAsErrors,
-            isTreatTagHintsAsErrors: options.isTreatTagHintsAsErrors,
-            maxShowIssues: options.maxShowIssues,
-            options: args['reporter-options'] ?? '',
-            preprocessorOptions: args['preprocessor-options'] ?? '',
-            selectedWorkspaces,
-        };
-        const finalData = await runPreprocessors(args.preprocessor ?? [], initialData);
+        const preprocess = await createPreprocessor(options.preprocessor);
+        const finalData = await preprocess(toReporterOptions(options, results, args));
         if (options.isFix)
             await fix(finalData.issues, finalData.counters, options);
         await runReporters(args.reporter ?? ['symbols'], finalData);
@@ -74,10 +54,16 @@ const main = async () => {
             console.log('\nTotal running time:', prettyMilliseconds(duration));
             perfObserver.reset();
         }
+        if (results.hasConfigLoadErrors) {
+            process.exitCode = 2;
+            return;
+        }
         if (!args['no-exit-code'] &&
             (totalErrorCount > options.maxIssues ||
-                (!options.isDisableConfigHints && options.isTreatConfigHintsAsErrors && configurationHints.length > 0) ||
-                (!options.isDisableTagHints && options.isTreatTagHintsAsErrors && tagHints.size > 0))) {
+                (!options.isDisableConfigHints &&
+                    options.isTreatConfigHintsAsErrors &&
+                    finalData.configurationHints.length > 0) ||
+                (!options.isDisableTagHints && options.isTreatTagHintsAsErrors && finalData.tagHints.size > 0))) {
             process.exitCode = 1;
             return;
         }