knip 5.42.1 → 5.42.3

package/dist/WorkspaceWorker.js

@@ -171,7 +171,7 @@ export class WorkspaceWorker {
         const inputsFromManifest = _getInputsFromScripts(Object.values(developmentScripts), baseOptions);
         const productionInputsFromManifest = _getInputsFromScripts(Object.values(productionScripts), baseOptions);
         const hasProductionInput = (input) => productionInputsFromManifest.find(d => d.specifier === input.specifier && d.type === input.type);
-        const getInputsFromScripts = (scripts, options) => _getInputsFromScripts(scripts, { ...baseScriptOptions, ...options });
+        const createGetInputsFromScripts = (containingFilePath) => (scripts, options) => _getInputsFromScripts(scripts, { ...baseOptions, ...options, containingFilePath });
         const inputs = [];
         const configFiles = new Map();
         const remainingPlugins = new Set(this.enabledPlugins);
@@ -217,12 +217,13 @@ export class WorkspaceWorker {
                 configFilePath: containingFilePath,
                 configFileDir: cwd,
                 configFileName: '',
-                getInputsFromScripts,
+                getInputsFromScripts: createGetInputsFromScripts(containingFilePath),
             };
             const configEntryPaths = [];
             for (const configFilePath of remainingConfigFilePaths) {
                 const opts = {
                     ...options,
+                    getInputsFromScripts: createGetInputsFromScripts(configFilePath),
                     configFilePath,
                     configFileDir: dirname(configFilePath),
                     configFileName: basename(configFilePath),
@@ -251,8 +252,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/bash-parser.js

@@ -3,6 +3,8 @@ import { Plugins, pluginArgsMap } from '../plugins.js';
 import { debugLogObject } from '../util/debug.js';
 import { toBinary, toDeferResolve } from '../util/input.js';
 import { extractBinary } from '../util/modules.js';
+import { relative } from '../util/path.js';
+import { truncate } from '../util/string.js';
 import { resolve as fallbackResolve } from './fallback.js';
 import PackageManagerResolvers from './package-manager/index.js';
 import { resolve as resolverFromPlugins } from './plugins.js';
@@ -85,7 +87,8 @@ export const getDependenciesFromScript = (script, options) => {
         return parsed?.commands ? getDependenciesFromNodes(parsed.commands) : [];
     }
     catch (error) {
-        debugLogObject('*', 'Bash parser error', error);
+        const msg = `Warning: failed to parse and ignoring script in ${relative(options.containingFilePath)} (${truncate(script, 30)})`;
+        debugLogObject('*', msg, error);
         return [];
     }
 };

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/index.js

@@ -252,18 +252,18 @@ export const main = async (unresolvedConfiguration) => {
             if (scripts && scripts.size > 0) {
                 const dependencies = deputy.getDependencies(workspace.name);
                 const manifestScriptNames = new Set(Object.keys(chief.getManifestForWorkspace(workspace.name)?.scripts ?? {}));
-                const rootCwd = cwd;
+                const dir = dirname(filePath);
                 const options = {
-                    cwd: dirname(filePath),
-                    rootCwd,
+                    cwd: dir,
+                    rootCwd: cwd,
                     containingFilePath: filePath,
                     dependencies,
                     manifestScriptNames,
                 };
                 const inputs = _getInputsFromScripts(scripts, options);
                 for (const input of inputs) {
-                    input.containingFilePath = filePath;
-                    input.dir = cwd;
+                    input.containingFilePath ??= filePath;
+                    input.dir ??= dir;
                     const specifierFilePath = getReferencedInternalFilePath(input, workspace);
                     if (specifierFilePath)
                         analyzeSourceFile(specifierFilePath, principal);

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/plugins/storybook/index.js

@@ -29,7 +29,8 @@ const resolveConfig = async (localConfig) => {
             ? [`@storybook/builder-${builder}`, `@storybook/manager-${builder}`]
             : [builder]
         : [];
-    const frameworks = localConfig.framework?.name ? [localConfig.framework.name] : [];
+    const framework = typeof localConfig.framework === 'string' ? localConfig.framework : localConfig.framework?.name;
+    const frameworks = framework ? [framework] : [];
     return [
         ...addons.map(toDeferResolve),
         ...builderPackages.map(id => toDependency(id)),

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

@@ -13,7 +13,7 @@ export type StorybookConfig = {
             name?: string;
         };
     };
-    framework?: {
+    framework?: string | {
         name?: string;
     };
 };

package/dist/plugins/vitest/helpers.js

@@ -30,5 +30,6 @@ const builtInReporters = [
 export const getExternalReporters = (reporters) => reporters
     ? [reporters]
         .flat()
+        .map(reporter => (Array.isArray(reporter) ? reporter[0] : reporter))
         .filter((reporter) => typeof reporter === 'string' && !builtInReporters.includes(reporter))
     : [];

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

@@ -8,7 +8,7 @@ interface VitestConfig {
         root?: string;
         environment?: string;
         globalSetup?: string | string[];
-        reporters?: (string | unknown)[];
+        reporters?: (string | [string, unknown] | unknown)[];
         setupFiles?: string | string[];
     };
 }

package/dist/reporters/symbols.js

@@ -2,11 +2,11 @@ import EasyTable from 'easy-table';
 import picocolors from 'picocolors';
 import { ROOT_WORKSPACE_NAME } from '../constants.js';
 import { relative, toRelative } from '../util/path.js';
+import { truncate } from '../util/string.js';
 import { getTitle, identity, logTitle } from './util.js';
 const dim = picocolors.gray;
 const bright = picocolors.whiteBright;
 const TRUNCATE_WIDTH = 40;
-const truncate = (text) => (text.length > TRUNCATE_WIDTH ? `${text.slice(0, TRUNCATE_WIDTH - 3)}...` : text);
 const truncateStart = (text, width) => (text.length > width ? `...${text.slice(-(width - 3))}` : text);
 const sortByPos = (a, b) => {
     const [f, r, c] = a.filePath.split(':');
@@ -28,7 +28,8 @@ const logIssueRecord = (issues) => {
     const table = new EasyTable();
     for (const issue of issues) {
         const print = issue.isFixed || issue.severity === 'warn' ? dim : identity;
-        table.cell('symbol', print(issue.symbols ? truncate(issue.symbols.map(s => s.symbol).join(', ')) : hl(issue)));
+        const symbols = issue.symbols;
+        table.cell('symbol', print(symbols ? truncate(symbols.map(s => s.symbol).join(', '), TRUNCATE_WIDTH) : hl(issue)));
         issue.parentSymbol && table.cell('parentSymbol', print(issue.parentSymbol));
         issue.symbolType && table.cell('symbolType', print(issue.symbolType));
         const pos = issue.line === undefined ? '' : `:${issue.line}${issue.col === undefined ? '' : `:${issue.col}`}`;

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/util/string.d.ts

@@ -0,0 +1 @@
+export declare const truncate: (text: string, width: number) => string;

package/dist/util/string.js

@@ -0,0 +1 @@
+export const truncate = (text, width) => text.length > width ? `${text.slice(0, width - 3)}...` : text;

package/dist/version.d.ts

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

package/dist/version.js

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

package/package.json

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