knip 5.42.1 → 5.42.2

package/dist/WorkspaceWorker.js

@@ -251,8 +251,9 @@ export class WorkspaceWorker {
                             if (hasResolveConfig) {
                                 const inputs = (await plugin.resolveConfig?.(config, opts)) ?? [];
                                 for (const input of inputs) {
-                                    if (isConfigPattern(input))
+                                    if (isConfigPattern(input)) {
                                         handleConfigInput(input.pluginName, { ...input, containingFilePath: configFilePath });
+                                    }
                                     addInput(input, configFilePath);
                                 }
                                 data.resolveConfig = inputs;

package/dist/binaries/package-manager/yarn.js

@@ -1,5 +1,6 @@
 import parseArgs from 'minimist';
-import { toBinary } from '../../util/input.js';
+import { isBinary, isDependency, toBinary, toDependency } from '../../util/input.js';
+import { stripVersionFromSpecifier } from '../../util/modules.js';
 import { join } from '../../util/path.js';
 const commands = [
     'add',
@@ -34,17 +35,39 @@ const commands = [
     'workspace',
     'workspaces',
 ];
-export const resolve = (_binary, args, { manifestScriptNames, fromArgs, cwd, rootCwd }) => {
+const resolveDlx = (args, options) => {
+    const parsed = parseArgs(args, {
+        boolean: ['quiet'],
+        alias: { package: 'p', quiet: 'q' },
+    });
+    const packageSpecifier = parsed._[0];
+    const specifier = packageSpecifier ? stripVersionFromSpecifier(packageSpecifier) : '';
+    const packages = parsed.package && !parsed.yes ? [parsed.package].flat().map(stripVersionFromSpecifier) : [];
+    const command = specifier ? options.fromArgs(parsed._) : [];
+    return [...packages.map(id => toDependency(id)), ...command].map(id => isDependency(id) || isBinary(id) ? Object.assign(id, { optional: true }) : id);
+};
+export const resolve = (_binary, args, options) => {
+    const { manifestScriptNames, fromArgs, cwd, rootCwd } = options;
     const parsed = parseArgs(args, { boolean: ['top-level'], string: ['cwd'] });
-    const [command, binary] = parsed._;
     const dir = parsed['top-level'] ? rootCwd : parsed.cwd ? join(cwd, parsed.cwd) : undefined;
-    if ((!dir && manifestScriptNames.has(command)) || commands.includes(command))
-        return [];
-    if (!dir && command === 'run' && manifestScriptNames.has(binary))
-        return [];
+    const [command, binary] = parsed._;
+    if (command === 'run') {
+        if (manifestScriptNames.has(binary))
+            return [];
+        const bin = toBinary(binary, { optional: true });
+        if (dir)
+            Object.assign(bin, { dir });
+        return [bin];
+    }
     if (command === 'node')
         return fromArgs(parsed._);
-    const bin = command === 'run' || command === 'exec' ? toBinary(binary) : toBinary(command);
+    if (command === 'dlx') {
+        const argsForDlx = args.filter(arg => arg !== 'dlx');
+        return resolveDlx(argsForDlx, options);
+    }
+    if ((!dir && manifestScriptNames.has(command)) || commands.includes(command))
+        return [];
+    const bin = command === 'exec' ? toBinary(binary) : toBinary(command);
     if (dir)
         Object.assign(bin, { dir });
     return [bin];

package/dist/plugins/angular/index.js

@@ -1,5 +1,6 @@
-import { toConfig, toDependency, toEntry, toProductionEntry } from '../../util/input.js';
-import { join } from '../../util/path.js';
+import { existsSync } from 'node:fs';
+import { toConfig, toDeferResolve, toDependency, toEntry, toProductionEntry } from '../../util/input.js';
+import { isInternal, join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import * as karma from '../karma/helpers.js';
 const title = 'Angular';
@@ -27,21 +28,31 @@ const resolveConfig = async (config, options) => {
             const defaultEntriesByOption = opts ? entriesByOption(opts) : new Map();
             const entriesByOptionByConfig = new Map(configs ? Object.entries(configs).map(([name, opts]) => [name, entriesByOption(opts)]) : []);
             const productionEntriesByOption = entriesByOptionByConfig.get(PRODUCTION_CONFIG_NAME) ?? new Map();
-            const normalizePath = (path) => join(cwd, path);
+            const isBuildTarget = targetName === BUILD_TARGET_NAME;
+            const maybeExternal = (option) => option === 'polyfills';
+            const toInput = (specifier, opts) => {
+                const normalizedPath = join(cwd, specifier);
+                if (opts.maybeExternal && !isInternal(specifier) && !existsSync(normalizedPath)) {
+                    return toDeferResolve(specifier);
+                }
+                return opts.isProduction ? toProductionEntry(normalizedPath) : toEntry(normalizedPath);
+            };
             for (const [configName, entriesByOption] of entriesByOptionByConfig.entries()) {
-                for (const entries of entriesByOption.values()) {
+                for (const [option, entries] of entriesByOption.entries()) {
                     for (const entry of entries) {
-                        inputs.add(targetName === BUILD_TARGET_NAME && configName === PRODUCTION_CONFIG_NAME
-                            ? toProductionEntry(normalizePath(entry))
-                            : toEntry(normalizePath(entry)));
+                        inputs.add(toInput(entry, {
+                            isProduction: isBuildTarget && configName === PRODUCTION_CONFIG_NAME,
+                            maybeExternal: maybeExternal(option),
+                        }));
                     }
                 }
             }
             for (const [option, entries] of defaultEntriesByOption.entries()) {
                 for (const entry of entries) {
-                    inputs.add(targetName === BUILD_TARGET_NAME && !productionEntriesByOption.get(option)?.length
-                        ? toProductionEntry(normalizePath(entry))
-                        : toEntry(normalizePath(entry)));
+                    inputs.add(toInput(entry, {
+                        isProduction: isBuildTarget && !productionEntriesByOption.get(option)?.length,
+                        maybeExternal: maybeExternal(option),
+                    }));
                 }
             }
             if (target.builder === '@angular-devkit/build-angular:karma' && opts) {
@@ -74,6 +85,11 @@ const entriesByOption = (opts) => new Map(Object.entries({
     scripts: 'scripts' in opts && opts.scripts && Array.isArray(opts.scripts)
         ? opts.scripts.map(scriptStringOrObject => typeof scriptStringOrObject === 'string' ? scriptStringOrObject : scriptStringOrObject.input)
         : [],
+    polyfills: 'polyfills' in opts && opts.polyfills
+        ? Array.isArray(opts.polyfills)
+            ? opts.polyfills
+            : [opts.polyfills]
+        : [],
     fileReplacements: 'fileReplacements' in opts && opts.fileReplacements && Array.isArray(opts.fileReplacements)
         ? opts.fileReplacements.map(fileReplacement => 'with' in fileReplacement ? fileReplacement.with : fileReplacement.replaceWith)
         : [],

package/dist/plugins/expo/helpers.d.ts

@@ -1,4 +1,4 @@
 import type { PluginOptions } from '../../types/config.js';
 import { type Input } from '../../util/input.js';
 import type { ExpoConfig } from './types.js';
-export declare const getDependencies: (expoConfig: ExpoConfig, { manifest }: PluginOptions) => Promise<Input[]>;
+export declare const getDependencies: (localConfig: ExpoConfig, { manifest }: PluginOptions) => Promise<Input[]>;

package/dist/plugins/expo/helpers.js

@@ -1,6 +1,7 @@
 import { toDependency, toProductionDependency } from '../../util/input.js';
 import { getPackageNameFromModuleSpecifier } from '../../util/modules.js';
-export const getDependencies = async (expoConfig, { manifest }) => {
+export const getDependencies = async (localConfig, { manifest }) => {
+    const expoConfig = typeof localConfig === 'function' ? localConfig() : localConfig;
     const config = 'expo' in expoConfig ? expoConfig.expo : expoConfig;
     const platforms = config.platforms ?? ['ios', 'android'];
     const pluginPackages = config.plugins

package/dist/plugins/expo/index.js

@@ -8,7 +8,8 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['app.json', 'app.config.{ts,js}'];
 const production = ['app/**/*.{js,jsx,ts,tsx}', 'src/app/**/*.{js,jsx,ts,tsx}'];
 export const docs = { production };
-const resolveEntryPaths = async (expoConfig, { manifest }) => {
+const resolveEntryPaths = async (localConfig, { manifest }) => {
+    const expoConfig = typeof localConfig === 'function' ? localConfig() : localConfig;
     const config = 'expo' in expoConfig ? expoConfig.expo : expoConfig;
     let patterns = [];
     if (manifest.main === 'expo-router/entry') {

package/dist/plugins/expo/types.d.ts

@@ -15,7 +15,8 @@ type AppConfig = {
     androidNavigationBar?: Record<string, unknown>;
     plugins?: (string | [string, Record<string, unknown>])[];
 };
-export type ExpoConfig = AppConfig | {
+type Config = AppConfig | {
     expo: AppConfig;
 };
+export type ExpoConfig = Config | (() => Config);
 export {};

package/dist/plugins/github-actions/index.js

@@ -8,8 +8,17 @@ const isEnabled = async ({ cwd }) => Boolean(await _firstGlob({ cwd, patterns: [
 const isRootOnly = true;
 const config = ['.github/workflows/*.{yml,yaml}', '.github/**/action.{yml,yaml}'];
 const isString = (value) => typeof value === 'string';
+const getActionDependencies = (config, options) => {
+    const { configFileDir, configFileName } = options;
+    const isActionManifest = configFileName === 'action.yml' || configFileName === 'action.yaml';
+    if (!(isActionManifest && config?.runs?.using?.startsWith('node')))
+        return [];
+    const runs = config.runs;
+    const scripts = [runs.pre, runs.main, runs.post].filter(isString);
+    return scripts.map(script => join(configFileDir, script));
+};
 const resolveConfig = async (config, options) => {
-    const { configFileDir, configFileName, rootCwd, getInputsFromScripts } = options;
+    const { rootCwd, getInputsFromScripts, isProduction } = options;
     const inputs = new Set();
     const jobs = findByKeyDeep(config, 'steps');
     for (const steps of jobs) {
@@ -22,21 +31,17 @@ const resolveConfig = async (config, options) => {
             const dir = join(rootCwd, path && workingDir ? relative(workingDir, path) : workingDir ? workingDir : '.');
             if (step.run) {
                 for (const input of getInputsFromScripts([step.run], { knownBinsOnly: true })) {
-                    if (isDeferResolveEntry(input) && path && !workingDir)
+                    if (isDeferResolveEntry(input) && path && !workingDir) {
                         input.specifier = relative(join(dir, path), join(rootCwd, input.specifier));
+                    }
+                    if (isProduction)
+                        Object.assign(input, { optional: true });
                     inputs.add({ ...input, dir });
                 }
             }
         }
     }
-    const getActionDependencies = () => {
-        const isActionManifest = configFileName === 'action.yml' || configFileName === 'action.yaml';
-        if (!(isActionManifest && config?.runs?.using?.startsWith('node')))
-            return [];
-        const scripts = [config.runs.pre, config.runs.main, config.runs.post].filter(isString);
-        return scripts.map(script => join(configFileDir, script));
-    };
-    return [...getActionDependencies().map(toEntry), ...inputs];
+    return [...inputs, ...getActionDependencies(config, options).map(toEntry)];
 };
 export default {
     title,

package/dist/plugins/github-actions/types.d.ts

@@ -0,0 +1,20 @@
+type Step = {
+    run?: string;
+    uses?: string;
+    with?: {
+        repository: string;
+        path: string;
+    };
+    'working-directory'?: string;
+};
+type Steps = Step[];
+export type Job = {
+    steps: Steps;
+};
+export type Runs = {
+    using: string;
+    main?: string;
+    pre?: string;
+    post?: string;
+};
+export {};

package/dist/plugins/github-actions/types.js

@@ -0,0 +1 @@
+export {};

package/dist/util/get-referenced-inputs.js

@@ -16,7 +16,7 @@ export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnore
         const binaryName = fromBinary(input);
         const inputWorkspace = getWorkspaceFor(input, chief, workspace);
         const isHandled = deputy.maybeAddReferencedBinary(inputWorkspace, binaryName);
-        if (isHandled)
+        if (isHandled || input.optional)
             return;
         collector.addIssue({
             type: 'binaries',

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.42.1";
+export declare const version = "5.42.2";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.42.1';
+export const version = '5.42.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.42.1",
+  "version": "5.42.2",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {