knip 5.75.1 → 5.76.0

package/README.md

@@ -21,28 +21,28 @@ performance, less maintenance and easier refactorings.
 - GitHub repo: [webpro-nl/knip][4]
 - npm package: [knip][1]
 - [Contributing Guide][7]
-- Follow [@webpro.nl on Bluesky][3] for updates
-- [Sponsor Knip!][8]
+- Follow [@webpro.nl on Bluesky][8] for updates
+- [Sponsor Knip!][9]
 
 ## Contributors
 
-Special thanks to [the wonderful people who have contributed to Knip][9]!
+Special thanks to [the wonderful people who have contributed to Knip][10]!
 
 ## Knip
 
-/'knɪp/ means "(to) cut" and is [pronounced with a hard "K"][10] 🇳🇱
+/'knɪp/ means "(to) cut" and is [pronounced with a hard "K"][11] 🇳🇱
 
 ## License
 
-Knip is free and open-source software licensed under the [ISC License][11].
+Knip is free and open-source software licensed under the [ISC License][12].
 
 Parts of Knip have been inspired by and/or partially copy code from the
 following projects:
 
-- [@npmcli/package-json][12] ([ISC][13])
-- [@pnpm/deps.graph-sequencer][14] ([MIT][15])
-- [file-entry-cache][16] ([MIT][17])
-- [json-parse-even-better-errors][18] ([MIT][19])
+- [@npmcli/package-json][13] ([ISC][14])
+- [@pnpm/deps.graph-sequencer][15] ([MIT][16])
+- [file-entry-cache][17] ([MIT][18])
+- [json-parse-even-better-errors][19] ([MIT][20])
 
 [1]: https://www.npmjs.com/package/knip
 [2]: https://img.shields.io/npm/v/knip?color=f56e0f
@@ -52,16 +52,17 @@ following projects:
   https://img.shields.io/github/stars/webpro-nl/knip?style=flat-square&color=f56e0f
 [6]: https://knip.dev
 [7]: https://github.com/webpro-nl/knip/blob/main/.github/CONTRIBUTING.md
-[8]: https://knip.dev/sponsors
-[9]: https://knip.dev/#created-by-awesome-contributors
-[10]: https://www.youtube.com/watch?v=PE7h7KvQoUI&t=9s
-[11]: ./license
-[12]: https://github.com/npm/package-json
-[13]: https://github.com/npm/package-json/blob/main/LICENSE
-[14]: https://github.com/pnpm/pnpm/tree/main/deps/graph-sequencer
-[15]: https://github.com/pnpm/pnpm/blob/main/LICENSE
-[16]: https://github.com/jaredwray/cacheable/tree/main/packages/file-entry-cache
-[17]:
+[8]: https://bsky.app/profile/webpro.nl
+[9]: https://knip.dev/sponsors
+[10]: https://knip.dev/#created-by-awesome-contributors
+[11]: https://www.youtube.com/watch?v=PE7h7KvQoUI&t=9s
+[12]: ./license
+[13]: https://github.com/npm/package-json
+[14]: https://github.com/npm/package-json/blob/main/LICENSE
+[15]: https://github.com/pnpm/pnpm/tree/main/deps/graph-sequencer
+[16]: https://github.com/pnpm/pnpm/blob/main/LICENSE
+[17]: https://github.com/jaredwray/cacheable/tree/main/packages/file-entry-cache
+[18]:
   https://github.com/jaredwray/cacheable/blob/main/packages/file-entry-cache/LICENSE
-[18]: https://github.com/npm/json-parse-even-better-errors
-[19]: https://github.com/npm/json-parse-even-better-errors/blob/main/LICENSE.md
+[19]: https://github.com/npm/json-parse-even-better-errors
+[20]: https://github.com/npm/json-parse-even-better-errors/blob/main/LICENSE.md

package/dist/DependencyDeputy.d.ts

@@ -56,7 +56,7 @@ export declare class DependencyDeputy {
     }[];
     getOptionalPeerDependencies(workspaceName: string): DependencyArray;
     maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string): boolean;
-    maybeAddReferencedBinary(workspace: Workspace, binaryName: string): boolean;
+    maybeAddReferencedBinary(workspace: Workspace, binaryName: string): Set<string> | undefined;
     private isInDependencies;
     settleDependencyIssues(): {
         dependencyIssues: Issue[];

package/dist/DependencyDeputy.js

@@ -146,7 +146,7 @@ export class DependencyDeputy {
     }
     maybeAddReferencedBinary(workspace, binaryName) {
         if (IGNORED_GLOBAL_BINARIES.has(binaryName))
-            return true;
+            return new Set();
         this.addReferencedBinary(workspace.name, binaryName);
         const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
         for (const name of workspaceNames) {
@@ -156,11 +156,11 @@ export class DependencyDeputy {
                 if (dependencies?.size) {
                     for (const dependency of dependencies)
                         this.addReferencedDependency(name, dependency);
-                    return true;
+                    return dependencies;
                 }
             }
         }
-        return false;
+        return;
     }
     isInDependencies(workspaceName, packageName) {
         const manifest = this._manifests.get(workspaceName);

package/dist/WorkspaceWorker.d.ts

@@ -1,6 +1,6 @@
 import { CacheConsultant } from './CacheConsultant.js';
 import { type Workspace } from './ConfigurationChief.js';
-import type { GetReferencedInternalFilePath, GetSourceFile, WorkspaceConfiguration } from './types/config.js';
+import type { GetSourceFile, HandleInput, WorkspaceConfiguration } from './types/config.js';
 import type { ConfigurationHint } from './types/issues.js';
 import type { PluginName } from './types/PluginNames.js';
 import type { PackageJson } from './types/package-json.js';
@@ -13,7 +13,7 @@ type WorkspaceManagerOptions = {
     config: WorkspaceConfiguration;
     manifest: PackageJson;
     dependencies: DependencySet;
-    getReferencedInternalFilePath: GetReferencedInternalFilePath;
+    handleInput: HandleInput;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
     getSourceFile: GetSourceFile;
     negatedWorkspacePatterns: string[];
@@ -33,7 +33,7 @@ export declare class WorkspaceWorker {
     config: WorkspaceConfiguration;
     manifest: PackageJson;
     dependencies: DependencySet;
-    getReferencedInternalFilePath: GetReferencedInternalFilePath;
+    handleInput: HandleInput;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
     getSourceFile: GetSourceFile;
     negatedWorkspacePatterns: string[];
@@ -44,7 +44,7 @@ export declare class WorkspaceWorker {
     enabledPluginsInAncestors: string[];
     cache: CacheConsultant<CacheItem>;
     configFilesMap: Map<string, Map<PluginName, Set<string>>>;
-    constructor({ name, dir, config, manifest, dependencies, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, findWorkspaceByFilePath, getSourceFile, configFilesMap, options, }: WorkspaceManagerOptions);
+    constructor({ name, dir, config, manifest, dependencies, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getSourceFile, configFilesMap, options, }: WorkspaceManagerOptions);
     init(): Promise<void>;
     private determineEnabledPlugins;
     private getConfigForPlugin;

package/dist/WorkspaceWorker.js

@@ -22,7 +22,7 @@ export class WorkspaceWorker {
     config;
     manifest;
     dependencies;
-    getReferencedInternalFilePath;
+    handleInput;
     findWorkspaceByFilePath;
     getSourceFile;
     negatedWorkspacePatterns = [];
@@ -33,7 +33,7 @@ export class WorkspaceWorker {
     enabledPluginsInAncestors;
     cache;
     configFilesMap;
-    constructor({ name, dir, config, manifest, dependencies, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, findWorkspaceByFilePath, getSourceFile, configFilesMap, options, }) {
+    constructor({ name, dir, config, manifest, dependencies, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getSourceFile, configFilesMap, options, }) {
         this.name = name;
         this.dir = dir;
         this.config = config;
@@ -43,7 +43,7 @@ export class WorkspaceWorker {
         this.ignoredWorkspacePatterns = ignoredWorkspacePatterns;
         this.enabledPluginsInAncestors = enabledPluginsInAncestors;
         this.configFilesMap = configFilesMap;
-        this.getReferencedInternalFilePath = getReferencedInternalFilePath;
+        this.handleInput = handleInput;
         this.findWorkspaceByFilePath = findWorkspaceByFilePath;
         this.getSourceFile = getSourceFile;
         this.options = options;
@@ -171,7 +171,7 @@ export class WorkspaceWorker {
         const configFiles = this.configFilesMap.get(wsName);
         const seen = new Map();
         const storeConfigFilePath = (pluginName, input) => {
-            const configFilePath = this.getReferencedInternalFilePath(input);
+            const configFilePath = this.handleInput(input);
             if (configFilePath) {
                 const workspace = this.findWorkspaceByFilePath(configFilePath);
                 if (workspace) {
@@ -272,11 +272,7 @@ export class WorkspaceWorker {
                 }
                 if (plugin.resolveFromAST) {
                     const sourceFile = this.getSourceFile(configFilePath);
-                    const resolveASTOpts = {
-                        ...resolveOpts,
-                        getSourceFile: this.getSourceFile,
-                        getReferencedInternalFilePath: this.getReferencedInternalFilePath,
-                    };
+                    const resolveASTOpts = { ...resolveOpts, getSourceFile: this.getSourceFile };
                     if (sourceFile) {
                         const inputs = plugin.resolveFromAST(sourceFile, resolveASTOpts);
                         for (const input of inputs)

package/dist/binaries/fallback.js

@@ -3,7 +3,7 @@ import { compact } from '../util/array.js';
 import { toBinary, toDeferResolve, toEntry } from '../util/input.js';
 import { isValidBinary } from './bash-parser.js';
 const spawningBinaries = ['cross-env', 'retry-cli'];
-const endOfCommandBinaries = ['dotenvx', 'env-cmd'];
+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 resolve = (binary, args, { fromArgs }) => {

package/dist/cli.js

@@ -7,9 +7,9 @@ import { perfObserver } from './util/Performance.js';
 import { runPreprocessors, runReporters } from './util/reporter.js';
 import { prettyMilliseconds } from './util/string.js';
 import { version } from './version.js';
-let parsedCLIArgs = {};
+let args = {};
 try {
-    parsedCLIArgs = parseArgs();
+    args = parseArgs();
 }
 catch (error) {
     if (error instanceof Error) {
@@ -21,12 +21,12 @@ catch (error) {
 }
 const run = async () => {
     try {
-        const options = await createOptions({ parsedCLIArgs });
-        if (parsedCLIArgs.help) {
+        const options = await createOptions({ args });
+        if (args.help) {
             console.log(helpText);
             process.exit(0);
         }
-        if (parsedCLIArgs.version) {
+        if (args.version) {
             console.log(version);
             process.exit(0);
         }
@@ -46,12 +46,12 @@ const run = async () => {
             isProduction: options.isProduction,
             isShowProgress: options.isShowProgress,
             isTreatConfigHintsAsErrors: options.isTreatConfigHintsAsErrors,
-            maxShowIssues: parsedCLIArgs['max-show-issues'] ? Number(parsedCLIArgs['max-show-issues']) : undefined,
-            options: parsedCLIArgs['reporter-options'] ?? '',
-            preprocessorOptions: parsedCLIArgs['preprocessor-options'] ?? '',
+            maxShowIssues: args['max-show-issues'] ? Number(args['max-show-issues']) : undefined,
+            options: args['reporter-options'] ?? '',
+            preprocessorOptions: args['preprocessor-options'] ?? '',
         };
-        const finalData = await runPreprocessors(parsedCLIArgs.preprocessor ?? [], initialData);
-        await runReporters(parsedCLIArgs.reporter ?? ['symbols'], finalData);
+        const finalData = await runPreprocessors(args.preprocessor ?? [], initialData);
+        await runReporters(args.reporter ?? ['symbols'], finalData);
         const totalErrorCount = Object.keys(finalData.report)
             .filter(reportGroup => finalData.report[reportGroup] && options.rules[reportGroup] === 'error')
             .reduce((errorCount, reportGroup) => errorCount + finalData.counters[reportGroup], 0);
@@ -59,27 +59,27 @@ const run = async () => {
             await perfObserver.finalize();
         if (perfObserver.isTimerifyFunctions)
             console.log(`\n${perfObserver.getTimerifiedFunctionsTable()}`);
-        if (perfObserver.isMemoryUsageEnabled && !parsedCLIArgs['memory-realtime'])
+        if (perfObserver.isMemoryUsageEnabled && !args['memory-realtime'])
             console.log(`\n${perfObserver.getMemoryUsageTable()}`);
         if (perfObserver.isEnabled) {
             const duration = perfObserver.getCurrentDurationInMs();
             console.log('\nTotal running time:', prettyMilliseconds(duration));
             perfObserver.reset();
         }
-        if (parsedCLIArgs['experimental-tags'] && parsedCLIArgs['experimental-tags'].length > 0) {
+        if (args['experimental-tags'] && args['experimental-tags'].length > 0) {
             logWarning('DEPRECATION WARNING', '--experimental-tags is deprecated, please start using --tags instead');
         }
         if (options.isIsolateWorkspaces && options.includedIssueTypes.classMembers) {
             logWarning('WARNING', 'Class members are not tracked when using the --isolate-workspaces flag');
         }
-        if ((!parsedCLIArgs['no-exit-code'] && totalErrorCount > Number(parsedCLIArgs['max-issues'] ?? 0)) ||
+        if ((!args['no-exit-code'] && totalErrorCount > Number(args['max-issues'] ?? 0)) ||
             (!options.isDisableConfigHints && options.isTreatConfigHintsAsErrors && configurationHints.size > 0)) {
             process.exit(1);
         }
     }
     catch (error) {
         process.exitCode = 2;
-        if (!parsedCLIArgs.debug && error instanceof Error && isKnownError(error)) {
+        if (!args.debug && error instanceof Error && isKnownError(error)) {
             const knownErrors = getKnownErrors(error);
             for (const knownError of knownErrors)
                 logError('ERROR', knownError.message);

package/dist/graph/analyze.js

@@ -1,10 +1,9 @@
 import { createGraphExplorer } from '../graph-explorer/explorer.js';
 import { getIssueType, hasStrictlyEnumReferences } from '../graph-explorer/utils.js';
+import traceReporter from '../reporters/trace.js';
 import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
-import { toRelative } from '../util/path.js';
 import { findMatch } from '../util/regex.js';
 import { getShouldIgnoreHandler, getShouldIgnoreTagHandler } from '../util/tag.js';
-import { formatTrace } from '../util/trace.js';
 export const analyze = async ({ analyzedFiles, counselor, chief, collector, deputy, entryPaths, factory, graph, streamer, unreferencedFiles, options, }) => {
     const shouldIgnore = getShouldIgnoreHandler(options.isProduction);
     const shouldIgnoreTags = getShouldIgnoreTagHandler(options.tags);
@@ -228,20 +227,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
             collector.addConfigurationHint(hint);
     };
     await analyzeGraph();
-    if (options.isTrace) {
-        const nodes = explorer.buildExportsTree({ filePath: options.traceFile, identifier: options.traceExport });
-        nodes.sort((a, b) => a.filePath.localeCompare(b.filePath) || a.identifier.localeCompare(b.identifier));
-        const toRel = (path) => toRelative(path, options.cwd);
-        const isReferenced = (node) => {
-            if (explorer.isReferenced(node.filePath, node.identifier, { includeEntryExports: false })[0])
-                return true;
-            if (explorer.hasStrictlyNsReferences(node.filePath, node.identifier)[0])
-                return true;
-            const exportItem = graph.get(node.filePath)?.exports.get(node.identifier);
-            return exportItem ? isExportReferencedInFile(exportItem) : false;
-        };
-        for (const node of nodes)
-            console.log(formatTrace(node, toRel, isReferenced(node)));
-    }
+    if (options.isTrace)
+        traceReporter({ graph, explorer, options, isExportReferencedInFile });
     return analyzeGraph;
 };

package/dist/graph/build.js

@@ -2,12 +2,12 @@ import { _getInputsFromScripts } from '../binaries/index.js';
 import { getCompilerExtensions, getIncludedCompilers } from '../compilers/index.js';
 import { DEFAULT_EXTENSIONS, FOREIGN_FILE_EXTENSIONS, IS_DTS } from '../constants.js';
 import { partition } from '../util/array.js';
+import { createInputHandler } from '../util/create-input-handler.js';
 import { debugLog, debugLogArray } from '../util/debug.js';
-import { getReferencedInputsHandler } from '../util/get-referenced-inputs.js';
 import { _glob, _syncGlob, negate, prependDirToPattern } from '../util/glob.js';
 import { isAlias, isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isIgnore, isProductionEntry, isProject, toProductionEntry, } from '../util/input.js';
 import { loadTSConfig } from '../util/load-tsconfig.js';
-import { updateImportMap } from '../util/module-graph.js';
+import { createFileNode, updateImportMap } from '../util/module-graph.js';
 import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
 import { perfObserver } from '../util/Performance.js';
 import { getEntrySpecifiersFromManifest, getManifestImportDependencies } from '../util/package-json.js';
@@ -20,7 +20,8 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
     const toModuleSourceFilePath = getModuleSourcePathHandler(chief);
     const toSourceFilePaths = getToSourcePathsHandler(chief);
     const addIssue = (issue) => collector.addIssue(issue) && options.isWatch && collector.retainIssue(issue);
-    const getReferencedInternalFilePath = getReferencedInputsHandler(deputy, chief, isGitIgnored, addIssue);
+    const externalRefsFromInputs = new Map();
+    const handleInput = createInputHandler(deputy, chief, isGitIgnored, addIssue, externalRefsFromInputs, options);
     for (const workspace of workspaces) {
         const { name, dir, manifestPath, manifestStr } = workspace;
         const manifest = chief.getManifestForWorkspace(name);
@@ -61,7 +62,7 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
             config,
             manifest,
             dependencies,
-            getReferencedInternalFilePath: (input) => getReferencedInternalFilePath(input, workspace),
+            handleInput: (input) => handleInput(input, workspace),
             findWorkspaceByFilePath: chief.findWorkspaceByFilePath.bind(chief),
             negatedWorkspacePatterns: chief.getNegatedWorkspacePatterns(name),
             ignoredWorkspacePatterns: chief.getIgnoredWorkspacesFor(name),
@@ -150,7 +151,7 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
             }
             else if (!isConfig(input)) {
                 const ws = (input.containingFilePath && chief.findWorkspaceByFilePath(input.containingFilePath)) || workspace;
-                const resolvedFilePath = getReferencedInternalFilePath(input, ws);
+                const resolvedFilePath = handleInput(input, ws);
                 if (resolvedFilePath) {
                     if (isDeferResolveProductionEntry(input)) {
                         addPattern(productionPatternsSkipExports, input, resolvedFilePath);
@@ -320,12 +321,16 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                 for (const input of inputs) {
                     input.containingFilePath ??= filePath;
                     input.dir ??= dir;
-                    const specifierFilePath = getReferencedInternalFilePath(input, workspace);
+                    const specifierFilePath = handleInput(input, workspace);
                     if (specifierFilePath)
                         principal.addEntryPath(specifierFilePath, { skipExportsAnalysis: true });
                 }
             }
             file.imports.unresolved = unresolvedImports;
+            const pluginRefs = externalRefsFromInputs.get(filePath);
+            if (pluginRefs)
+                for (const ref of pluginRefs)
+                    file.imports.externalRefs.add(ref);
             const node = graph.get(filePath);
             if (node) {
                 node.imports = file.imports;
@@ -380,6 +385,12 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
         }
         principals.length = 0;
     }
+    for (const [filePath, refs] of externalRefsFromInputs) {
+        if (!graph.has(filePath))
+            graph.set(filePath, createFileNode());
+        for (const ref of refs)
+            graph.get(filePath).imports.externalRefs.add(ref);
+    }
     return {
         graph,
         entryPaths,

package/dist/graph-explorer/explorer.d.ts

@@ -7,7 +7,8 @@ export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<s
     buildExportsTree: (options: {
         filePath?: string;
         identifier?: string;
-    }) => import("./operations/build-exports-tree.js").TreeNode[];
+    }) => import("./operations/build-exports-tree.js").ExportsTreeNode[];
+    getDependencyUsage: (pattern?: string | RegExp) => Map<string, import("./operations/get-dependency-usage.js").DependencyNodes>;
     resolveDefinition: (filePath: string, identifier: string) => import("./operations/resolve-definition.js").DefinitionResult | null;
     getUsage: (filePath: string, identifier: string) => import("./operations/get-usage.js").UsageResult;
     findCycles: (filePath: string, maxDepth?: number) => import("../session/types.js").Cycle[];

package/dist/graph-explorer/explorer.js

@@ -2,6 +2,7 @@ import { invalidateCache as invalidateCacheInternal } from './cache.js';
 import { buildExportsTree } from './operations/build-exports-tree.js';
 import { findCycles } from './operations/find-cycles.js';
 import { getContention } from './operations/get-contention.js';
+import { getDependencyUsage } from './operations/get-dependency-usage.js';
 import { getUsage } from './operations/get-usage.js';
 import { hasStrictlyNsReferences } from './operations/has-strictly-ns-references.js';
 import { isReferenced } from './operations/is-referenced.js';
@@ -11,6 +12,7 @@ export const createGraphExplorer = (graph, entryPaths) => {
         isReferenced: (filePath, identifier, options) => isReferenced(graph, entryPaths, filePath, identifier, options),
         hasStrictlyNsReferences: (filePath, identifier) => hasStrictlyNsReferences(graph, graph.get(filePath)?.imported, identifier),
         buildExportsTree: (options) => buildExportsTree(graph, entryPaths, options),
+        getDependencyUsage: (pattern) => getDependencyUsage(graph, pattern),
         resolveDefinition: (filePath, identifier) => resolveDefinition(graph, filePath, identifier),
         getUsage: (filePath, identifier) => getUsage(graph, entryPaths, filePath, identifier),
         findCycles: (filePath, maxDepth) => findCycles(graph, filePath, maxDepth),

package/dist/graph-explorer/operations/build-exports-tree.d.ts

@@ -1,15 +1,15 @@
 import type { Identifier, ModuleGraph } from '../../types/module-graph.js';
 import type { Via } from '../walk-down.js';
-export interface TreeNode {
+export interface ExportsTreeNode {
     filePath: string;
     identifier: string;
     originalId: string | undefined;
     via: Via | undefined;
     refs: string[];
     isEntry: boolean;
-    children: TreeNode[];
+    children: ExportsTreeNode[];
 }
 export declare const buildExportsTree: (graph: ModuleGraph, entryPaths: Set<string>, options: {
     filePath?: string;
     identifier?: Identifier;
-}) => TreeNode[];
+}) => ExportsTreeNode[];

package/dist/graph-explorer/operations/get-dependency-usage.d.ts

@@ -0,0 +1,14 @@
+import type { ModuleGraph } from '../../types/module-graph.js';
+export interface DependencyNode {
+    filePath: string;
+    specifier: string;
+    binaryName: string | undefined;
+    pos: number | undefined;
+    line: number | undefined;
+    col: number | undefined;
+}
+export interface DependencyNodes {
+    packageName: string;
+    imports: DependencyNode[];
+}
+export declare const getDependencyUsage: (graph: ModuleGraph, pattern?: string | RegExp) => Map<string, DependencyNodes>;

package/dist/graph-explorer/operations/get-dependency-usage.js

@@ -0,0 +1,38 @@
+import { getPackageNameFromModuleSpecifier } from '../../util/modules.js';
+export const getDependencyUsage = (graph, pattern) => {
+    const result = new Map();
+    const isMatch = (packageName, binaryName) => {
+        if (!pattern)
+            return true;
+        if (typeof pattern === 'string')
+            return packageName === pattern || binaryName === pattern;
+        return pattern.test(packageName) || (binaryName !== undefined && pattern.test(binaryName));
+    };
+    const addEntry = (packageName, filePath, specifier, binaryName, pos, line, col) => {
+        let entry = result.get(packageName);
+        if (!entry) {
+            entry = { packageName, imports: [] };
+            result.set(packageName, entry);
+        }
+        entry.imports.push({ filePath, specifier, binaryName, pos, line, col });
+    };
+    for (const [filePath, file] of graph) {
+        if (file.imports?.external) {
+            for (const _import of file.imports.external) {
+                const packageName = getPackageNameFromModuleSpecifier(_import.specifier);
+                if (packageName && isMatch(packageName)) {
+                    addEntry(packageName, filePath, _import.specifier, undefined, _import.pos, _import.line, _import.col);
+                }
+            }
+        }
+        if (file.imports?.externalRefs) {
+            for (const ref of file.imports.externalRefs) {
+                const packageName = getPackageNameFromModuleSpecifier(ref.specifier);
+                if (packageName && isMatch(packageName, ref.identifier)) {
+                    addEntry(packageName, filePath, ref.specifier, ref.identifier, undefined, undefined, undefined);
+                }
+            }
+        }
+    }
+    return result;
+};

package/dist/plugins/sst/resolveFromAST.js

@@ -1,8 +1,9 @@
 import ts from 'typescript';
 import { getImportMap, getPropertyValues } from '../../typescript/ast-helpers.js';
 import { toDeferResolveProductionEntry } from '../../util/input.js';
+import { dirname } from '../../util/path.js';
+import { _resolveSync } from '../../util/resolve.js';
 export const getInputsFromHandlers = (sourceFile, options) => {
-    const { getSourceFile, getReferencedInternalFilePath } = options;
     const entries = new Set();
     const importMap = getImportMap(sourceFile);
     function addHandlerSpecifiers(node) {
@@ -21,10 +22,9 @@ export const getInputsFromHandlers = (sourceFile, options) => {
                     if (ts.isIdentifier(arg)) {
                         const importPath = importMap.get(arg.text);
                         if (importPath) {
-                            const input = toDeferResolveProductionEntry(importPath, { containingFilePath: options.configFilePath });
-                            const resolvedPath = getReferencedInternalFilePath(input);
+                            const resolvedPath = _resolveSync(importPath, dirname(options.configFilePath));
                             if (resolvedPath) {
-                                const stackFile = getSourceFile(resolvedPath);
+                                const stackFile = options.getSourceFile(resolvedPath);
                                 if (stackFile)
                                     ts.forEachChild(stackFile, addHandlerSpecifiers);
                             }

package/dist/reporters/githubActions.js

@@ -33,6 +33,7 @@ export default ({ report, issues, cwd, configurationHints, isDisableConfigHints,
         if (isReportType) {
             const title = reportMultipleGroups && getIssueTypeTitle(reportType);
             const issuesForType = Object.values(issues[reportType]).flatMap(Object.values);
+            issuesForType.sort((a, b) => a.filePath.localeCompare(b.filePath) || (a.line ?? 0) - (b.line ?? 0));
             if (issuesForType.length > 0) {
                 title && core.info(`${title} (${issuesForType.length})`);
                 for (const issue of issuesForType) {
@@ -56,7 +57,8 @@ export default ({ report, issues, cwd, configurationHints, isDisableConfigHints,
     if (!isDisableConfigHints && configurationHints.size > 0) {
         const CONFIG_HINTS_TITLE = 'Configuration hints';
         core.info(`${CONFIG_HINTS_TITLE} (${configurationHints.size})`);
-        for (const hint of configurationHints) {
+        const sortedHints = [...configurationHints].sort((a, b) => (a.filePath ?? '').localeCompare(b.filePath ?? ''));
+        for (const hint of sortedHints) {
             const hintPrinter = hintPrinters.get(hint.type);
             const message = hintPrinter?.print({
                 ...hint,

package/dist/reporters/trace.d.ts

@@ -0,0 +1,11 @@
+import type { GraphExplorer } from '../graph-explorer/explorer.js';
+import type { Export, ExportMember, ModuleGraph } from '../types/module-graph.js';
+import type { MainOptions } from '../util/create-options.js';
+interface TraceReporterOptions {
+    graph: ModuleGraph;
+    explorer: GraphExplorer;
+    options: MainOptions;
+    isExportReferencedInFile: (exportedItem: Export | ExportMember) => boolean;
+}
+declare const _default: ({ graph, explorer, options, isExportReferencedInFile }: TraceReporterOptions) => void;
+export default _default;

package/dist/reporters/trace.js

@@ -0,0 +1,45 @@
+import pc from 'picocolors';
+import { join, toRelative } from '../util/path.js';
+import { toRegexOrString } from '../util/regex.js';
+import { Table } from '../util/table.js';
+import { formatTrace } from '../util/trace.js';
+export default ({ graph, explorer, options, isExportReferencedInFile }) => {
+    if (options.traceDependency) {
+        const pattern = toRegexOrString(options.traceDependency);
+        const workspaceDir = options.workspace ? join(options.cwd, options.workspace) : undefined;
+        const toRel = (path) => toRelative(path, options.cwd);
+        const table = new Table({ truncateStart: ['filePath'] });
+        const seen = new Set();
+        for (const [packageName, { imports }] of explorer.getDependencyUsage(pattern)) {
+            const filtered = workspaceDir ? imports.filter(i => i.filePath.startsWith(workspaceDir)) : imports;
+            filtered.sort((a, b) => a.filePath.localeCompare(b.filePath) || (a.line ?? 0) - (b.line ?? 0));
+            for (const _import of filtered) {
+                const pos = _import.line ? `:${_import.line}:${_import.col}` : '';
+                const key = `${_import.filePath}${pos}:${packageName}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                table.row();
+                table.cell('filePath', pc.whiteBright(`${toRel(_import.filePath)}${pos}`));
+                table.cell('package', pc.cyanBright(packageName));
+            }
+        }
+        for (const line of table.toRows())
+            console.log(line);
+    }
+    else {
+        const nodes = explorer.buildExportsTree({ filePath: options.traceFile, identifier: options.traceExport });
+        nodes.sort((a, b) => a.filePath.localeCompare(b.filePath) || a.identifier.localeCompare(b.identifier));
+        const toRel = (path) => toRelative(path, options.cwd);
+        const isReferenced = (node) => {
+            if (explorer.isReferenced(node.filePath, node.identifier, { includeEntryExports: false })[0])
+                return true;
+            if (explorer.hasStrictlyNsReferences(node.filePath, node.identifier)[0])
+                return true;
+            const exportItem = graph.get(node.filePath)?.exports.get(node.identifier);
+            return exportItem ? isExportReferencedInFile(exportItem) : false;
+        };
+        for (const node of nodes)
+            console.log(formatTrace(node, toRel, isReferenced(node)));
+    }
+};

package/dist/session/file-descriptor.d.ts

@@ -3,4 +3,4 @@ import type { File } from './types.js';
 export interface FileDescriptorOptions {
     isShowContention?: boolean;
 }
-export declare const buildFileDescriptor: (filePath: string, cwd: string, graph: ModuleGraph, entryPaths: Set<string>, options?: FileDescriptorOptions) => File | null;
+export declare const buildFileDescriptor: (filePath: string, cwd: string, graph: ModuleGraph, entryPaths: Set<string>, options?: FileDescriptorOptions) => File | undefined;

package/dist/session/file-descriptor.js

@@ -5,7 +5,7 @@ export const buildFileDescriptor = (filePath, cwd, graph, entryPaths, options =
     const absolutePath = toAbsolute(filePath, cwd);
     const node = graph.get(absolutePath);
     if (!node)
-        return null;
+        return;
     const explorer = createGraphExplorer(graph, entryPaths);
     const metrics = { imports: 0, exports: 0, cycles: 0, contention: 0 };
     let t0 = performance.now();

package/dist/session/index.d.ts

@@ -1,4 +1,5 @@
 export { IMPORT_STAR, KNIP_CONFIG_LOCATIONS, SIDE_EFFECTS } from '../constants.js';
+export type { DependencyNode, DependencyNodes } from '../graph-explorer/operations/get-dependency-usage.js';
 export { finalizeConfigurationHints } from '../reporters/util/configuration-hints.js';
 export { getIssuePrefix } from '../reporters/util/util.js';
 export type { Results } from '../run.js';
@@ -6,5 +7,6 @@ export type { Issue, Issues, IssueType, Rules } from '../types/issues.js';
 export type { PackageJson } from '../types/package-json.js';
 export { createOptions, type MainOptions } from '../util/create-options.js';
 export { buildFileDescriptor, type FileDescriptorOptions } from './file-descriptor.js';
+export { buildPackageJsonDescriptor, type PackageJsonFile } from './package-json-descriptor.js';
 export { createSession, type Session } from './session.js';
 export type { ContentionDetails, Export, File, SourceLocation } from './types.js';

package/dist/session/index.js

@@ -3,4 +3,5 @@ export { finalizeConfigurationHints } from '../reporters/util/configuration-hint
 export { getIssuePrefix } from '../reporters/util/util.js';
 export { createOptions } from '../util/create-options.js';
 export { buildFileDescriptor } from './file-descriptor.js';
+export { buildPackageJsonDescriptor } from './package-json-descriptor.js';
 export { createSession } from './session.js';

package/dist/session/package-json-descriptor.d.ts

@@ -0,0 +1,6 @@
+import type { DependencyNodes } from '../graph-explorer/operations/get-dependency-usage.js';
+import type { ModuleGraph } from '../types/module-graph.js';
+export interface PackageJsonFile {
+    dependenciesUsage: Map<string, DependencyNodes>;
+}
+export declare const buildPackageJsonDescriptor: (graph: ModuleGraph, entryPaths: Set<string>) => PackageJsonFile;

package/dist/session/package-json-descriptor.js

@@ -0,0 +1,7 @@
+import { createGraphExplorer } from '../graph-explorer/explorer.js';
+export const buildPackageJsonDescriptor = (graph, entryPaths) => {
+    const explorer = createGraphExplorer(graph, entryPaths);
+    return {
+        dependenciesUsage: explorer.getDependencyUsage(),
+    };
+};

package/dist/session/session.d.ts

@@ -4,6 +4,7 @@ import { type Results } from '../run.js';
 import type { MainOptions } from '../util/create-options.js';
 import type { WatchChange } from '../util/watch.js';
 import { type FileDescriptorOptions } from './file-descriptor.js';
+import { type PackageJsonFile } from './package-json-descriptor.js';
 import type { File } from './types.js';
 type WatchUpdate = {
     duration: number;
@@ -14,7 +15,8 @@ export interface Session {
     getIssues(): CollectorIssues;
     getResults(): Results;
     getConfigurationHints(): ProcessedHint[];
-    describeFile(filePath: string, options?: FileDescriptorOptions): File | null;
+    describeFile(filePath: string, options?: FileDescriptorOptions): File | undefined;
+    describePackageJson(): PackageJsonFile;
 }
 export declare const createSession: (options: MainOptions) => Promise<Session>;
 export {};

package/dist/session/session.js

@@ -1,6 +1,7 @@
 import { finalizeConfigurationHints } from '../reporters/util/configuration-hints.js';
 import { run } from '../run.js';
 import { buildFileDescriptor } from './file-descriptor.js';
+import { buildPackageJsonDescriptor } from './package-json-descriptor.js';
 export const createSession = async (options) => {
     const { session, results } = await run(options);
     if (!session)
@@ -14,5 +15,6 @@ const createSessionAdapter = (session, results, options) => {
         getResults: () => results,
         getConfigurationHints: () => finalizeConfigurationHints(results, options),
         describeFile: (filePath, opts) => buildFileDescriptor(filePath, options.cwd, session.getGraph(), session.getEntryPaths(), opts),
+        describePackageJson: () => buildPackageJsonDescriptor(session.getGraph(), session.getEntryPaths()),
     };
 };

package/dist/types/config.d.ts

@@ -96,10 +96,9 @@ export type IsLoadConfig = (options: PluginOptions, dependencies: Set<string>) =
 export type ResolveConfig<T = any> = (config: T, options: PluginOptions) => Promise<Input[]> | Input[];
 export type Resolve = (options: PluginOptions) => Promise<Input[]> | Input[];
 export type GetSourceFile = (filePath: string) => ts.SourceFile | undefined;
-export type GetReferencedInternalFilePath = (input: Input) => string | undefined;
+export type HandleInput = (input: Input) => string | undefined;
 export type ResolveFromAST = (sourceFile: ts.SourceFile, options: PluginOptions & {
     getSourceFile: GetSourceFile;
-    getReferencedInternalFilePath: GetReferencedInternalFilePath;
 }) => Input[];
 export interface Plugin {
     title: string;

package/dist/types/module-graph.d.ts

@@ -30,6 +30,10 @@ export interface Import extends Position {
     readonly identifier: string | undefined;
     readonly isTypeOnly: boolean;
 }
+export interface ExternalRef {
+    readonly specifier: string;
+    readonly identifier: string | undefined;
+}
 export interface Export extends Position {
     readonly identifier: Identifier;
     readonly type: SymbolType;
@@ -58,6 +62,7 @@ export type FileNode = {
     imports: {
         readonly internal: ImportMap;
         readonly external: Set<Import>;
+        readonly externalRefs: Set<ExternalRef>;
         unresolved: Set<Import>;
         readonly programFiles: Set<FilePath>;
         readonly entryFiles: Set<FilePath>;

package/dist/typescript/get-imports-and-exports.js

@@ -164,7 +164,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                         filePath,
                         specifier: sanitizedSpecifier,
                         identifier: opts.identifier ?? SIDE_EFFECTS,
-                        pos: opts.pos,
+                        pos,
                         line: line + 1,
                         col: character + 2,
                         isTypeOnly: !!(opts.modifiers & IMPORT_FLAGS.TYPE_ONLY),
@@ -445,7 +445,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         item.symbol = undefined;
     }
     return {
-        imports: { internal, external, programFiles, entryFiles, imports, unresolved },
+        imports: { internal, external, externalRefs: new Set(), programFiles, entryFiles, imports, unresolved },
         exports,
         duplicates: [...aliasedExports.values()],
         scripts,

package/dist/util/catalog.js

@@ -24,8 +24,10 @@ const extractNamedEntries = (catalogs) => {
     const entries = new Set();
     if (catalogs && typeof catalogs === 'object') {
         for (const [catalogName, catalog] of Object.entries(catalogs)) {
-            for (const name of Object.keys(catalog))
-                entries.add(`${catalogName}:${name}`);
+            if (catalog && typeof catalog === 'object') {
+                for (const name of Object.keys(catalog))
+                    entries.add(`${catalogName}:${name}`);
+            }
         }
     }
     return entries;

package/dist/util/cli-arguments.d.ts

@@ -1,4 +1,4 @@
-export declare const helpText = "\u2702\uFE0F  Find unused dependencies, exports and files in your JavaScript and TypeScript projects\n\nUsage: knip [options]\n\nOptions:\n  -c, --config [file]      Configuration file path (default: [.]knip.json[c], knip.(js|ts), knip.config.(js|ts) or package.json#knip)\n  -t, --tsConfig [file]    TypeScript configuration path (default: tsconfig.json)\n  --production             Analyze only production source files (e.g. no test files, devDependencies)\n  --strict                 Consider only direct dependencies of workspace (not devDependencies, not other workspaces)\n  -W, --workspace [dir]    Analyze a single workspace (default: analyze all configured workspaces)\n  --directory [dir]        Run process from a different directory (default: cwd)\n  --cache                  Enable caching\n  --cache-location         Change cache location (default: node_modules/.cache/knip)\n  --watch                  Watch mode\n  --no-gitignore           Don't use .gitignore\n  --include                Report only provided issue type(s), can be comma-separated or repeated (1)\n  --exclude                Exclude provided issue type(s) from report, can be comma-separated or repeated (1)\n  --dependencies           Shortcut for --include dependencies,unlisted,binaries,unresolved,catalog\n  --exports                Shortcut for --include exports,nsExports,classMembers,types,nsTypes,enumMembers,duplicates\n  --files                  Shortcut for --include files\n  --fix                    Fix issues\n  --fix-type               Fix only issues of type, can be comma-separated or repeated (2)\n  --format                 Format modified files after --fix using the local formatter\n  --allow-remove-files     Allow Knip to remove files (with --fix)\n  --include-libs           Include type definitions from external dependencies (default: false)\n  --include-entry-exports  Include entry files when reporting unused exports\n  --isolate-workspaces     Isolate workspaces into separate programs\n  --use-tsconfig-files     Use tsconfig.json to define project files (override `project` patterns)\n  -n, --no-progress        Don't show dynamic progress updates (automatically enabled in CI environments)\n  --preprocessor           Preprocess the results before providing it to the reporter(s), can be repeated\n  --preprocessor-options   Pass extra options to the preprocessor (as JSON string, see --reporter-options example)\n  --reporter               Select reporter: symbols, compact, codeowners, json, codeclimate, markdown, disclosure, github-actions, can be repeated (default: symbols)\n  --reporter-options       Pass extra options to the reporter (as JSON string, see example)\n  --tags                   Include or exclude tagged exports\n  --no-config-hints        Suppress configuration hints\n  --treat-config-hints-as-errors    Exit with non-zero code (1) if there are any configuration hints\n  --no-exit-code           Always exit with code zero (0)\n  --max-issues             Maximum number of total issues before non-zero exit code (default: 0)\n  --max-show-issues     Maximum number of issues to display per type\n  -d, --debug              Show debug output\n  --trace                  Show trace output\n  --trace-export [name]    Show trace output for named export(s)\n  --trace-file [file]      Show trace output for exports in file\n  --performance            Measure count and running time of key functions and display stats table\n  --performance-fn [name]  Measure only function [name]\n  --memory                 Measure memory usage and display data table\n  --memory-realtime        Log memory usage in realtime\n  -h, --help               Print this help text\n  -V, --version            Print version\n\n(1) Issue types: files, dependencies, unlisted, unresolved, exports, nsExports, classMembers, types, nsTypes, enumMembers, duplicates, catalog\n(2) Fixable issue types: dependencies, exports, types, catalog\n\nExamples:\n\n$ knip\n$ knip --production\n$ knip --workspace packages/client --include files,dependencies\n$ knip -c ./config/knip.json --reporter compact\n$ knip --reporter codeowners --reporter-options '{\"path\":\".github/CODEOWNERS\"}'\n$ knip --tags=-lintignore\n\nWebsite: https://knip.dev";
+export declare const helpText = "\u2702\uFE0F  Find unused dependencies, exports and files in your JavaScript and TypeScript projects\n\nUsage: knip [options]\n\nOptions:\n  -c, --config [file]      Configuration file path (default: [.]knip.json[c], knip.(js|ts), knip.config.(js|ts) or package.json#knip)\n  -t, --tsConfig [file]    TypeScript configuration path (default: tsconfig.json)\n  --production             Analyze only production source files (e.g. no test files, devDependencies)\n  --strict                 Consider only direct dependencies of workspace (not devDependencies, not other workspaces)\n  -W, --workspace [dir]    Analyze a single workspace (default: analyze all configured workspaces)\n  --directory [dir]        Run process from a different directory (default: cwd)\n  --cache                  Enable caching\n  --cache-location         Change cache location (default: node_modules/.cache/knip)\n  --watch                  Watch mode\n  --no-gitignore           Don't use .gitignore\n  --include                Report only provided issue type(s), can be comma-separated or repeated (1)\n  --exclude                Exclude provided issue type(s) from report, can be comma-separated or repeated (1)\n  --dependencies           Shortcut for --include dependencies,unlisted,binaries,unresolved,catalog\n  --exports                Shortcut for --include exports,nsExports,classMembers,types,nsTypes,enumMembers,duplicates\n  --files                  Shortcut for --include files\n  --fix                    Fix issues\n  --fix-type               Fix only issues of type, can be comma-separated or repeated (2)\n  --format                 Format modified files after --fix using the local formatter\n  --allow-remove-files     Allow Knip to remove files (with --fix)\n  --include-libs           Include type definitions from external dependencies (default: false)\n  --include-entry-exports  Include entry files when reporting unused exports\n  --isolate-workspaces     Isolate workspaces into separate programs\n  --use-tsconfig-files     Use tsconfig.json to define project files (override `project` patterns)\n  -n, --no-progress        Don't show dynamic progress updates (automatically enabled in CI environments)\n  --preprocessor           Preprocess the results before providing it to the reporter(s), can be repeated\n  --preprocessor-options   Pass extra options to the preprocessor (as JSON string, see --reporter-options example)\n  --reporter               Select reporter: symbols, compact, codeowners, json, codeclimate, markdown, disclosure, github-actions, can be repeated (default: symbols)\n  --reporter-options       Pass extra options to the reporter (as JSON string, see example)\n  --tags                   Include or exclude tagged exports\n  --no-config-hints        Suppress configuration hints\n  --treat-config-hints-as-errors    Exit with non-zero code (1) if there are any configuration hints\n  --no-exit-code           Always exit with code zero (0)\n  --max-issues             Maximum number of total issues before non-zero exit code (default: 0)\n  --max-show-issues        Maximum number of issues to display per type\n  -d, --debug              Show debug output\n  --trace                  Show trace output\n  --trace-dependency [name] Show files that import the named dependency\n  --trace-export [name]    Show trace output for named export(s)\n  --trace-file [file]      Show trace output for exports in file\n  --performance            Measure count and running time of key functions and display stats table\n  --performance-fn [name]  Measure only function [name]\n  --memory                 Measure memory usage and display data table\n  --memory-realtime        Log memory usage in realtime\n  -h, --help               Print this help text\n  -V, --version            Print version\n\n(1) Issue types: files, dependencies, unlisted, unresolved, exports, nsExports, classMembers, types, nsTypes, enumMembers, duplicates, catalog\n(2) Fixable issue types: dependencies, exports, types, catalog\n\nExamples:\n\n$ knip\n$ knip --production\n$ knip --workspace packages/client --include files,dependencies\n$ knip -c ./config/knip.json --reporter compact\n$ knip --reporter codeowners --reporter-options '{\"path\":\".github/CODEOWNERS\"}'\n$ knip --tags=-lintignore\n\nWebsite: https://knip.dev";
 export type ParsedCLIArgs = ReturnType<typeof parseCLIArgs>;
 export default function parseCLIArgs(): {
     cache?: boolean | undefined;
@@ -39,6 +39,7 @@ export default function parseCLIArgs(): {
     'reporter-options'?: string | undefined;
     strict?: boolean | undefined;
     trace?: boolean | undefined;
+    'trace-dependency'?: string | undefined;
     'trace-export'?: string | undefined;
     'trace-file'?: string | undefined;
     'treat-config-hints-as-errors'?: boolean | undefined;

package/dist/util/cli-arguments.js

@@ -37,9 +37,10 @@ Options:
   --treat-config-hints-as-errors    Exit with non-zero code (1) if there are any configuration hints
   --no-exit-code           Always exit with code zero (0)
   --max-issues             Maximum number of total issues before non-zero exit code (default: 0)
-  --max-show-issues     Maximum number of issues to display per type
+  --max-show-issues        Maximum number of issues to display per type
   -d, --debug              Show debug output
   --trace                  Show trace output
+  --trace-dependency [name] Show files that import the named dependency
   --trace-export [name]    Show trace output for named export(s)
   --trace-file [file]      Show trace output for exports in file
   --performance            Measure count and running time of key functions and display stats table
@@ -103,6 +104,7 @@ export default function parseCLIArgs() {
             'reporter-options': { type: 'string' },
             strict: { type: 'boolean' },
             trace: { type: 'boolean' },
+            'trace-dependency': { type: 'string' },
             'trace-export': { type: 'string' },
             'trace-file': { type: 'string' },
             'treat-config-hints-as-errors': { type: 'boolean' },

package/dist/util/create-input-handler.d.ts

@@ -0,0 +1,8 @@
+import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
+import type { DependencyDeputy } from '../DependencyDeputy.js';
+import type { Issue } from '../types/issues.js';
+import type { ExternalRef } from '../types/module-graph.js';
+import type { MainOptions } from './create-options.js';
+import { type Input } from './input.js';
+export type ExternalRefsFromInputs = Map<string, Set<ExternalRef>>;
+export declare const createInputHandler: (deputy: DependencyDeputy, chief: ConfigurationChief, isGitIgnored: (filePath: string) => boolean, addIssue: (issue: Issue) => void, externalRefs: ExternalRefsFromInputs, options: MainOptions) => (input: Input, workspace: Workspace) => string | undefined;

package/dist/util/{get-referenced-inputs.js → create-input-handler.js}

@@ -7,15 +7,26 @@ import { _resolveSync } from './resolve.js';
 const getWorkspaceFor = (input, chief, workspace) => (input.dir && chief.findWorkspaceByFilePath(`${input.dir}/`)) ||
     (input.containingFilePath && chief.findWorkspaceByFilePath(input.containingFilePath)) ||
     workspace;
-export const getReferencedInputsHandler = (deputy, chief, isGitIgnored, addIssue) => (input, workspace) => {
+const addExternalRef = (map, containingFilePath, ref) => {
+    if (!map.has(containingFilePath))
+        map.set(containingFilePath, new Set());
+    map.get(containingFilePath).add(ref);
+};
+export const createInputHandler = (deputy, chief, isGitIgnored, addIssue, externalRefs, options) => (input, workspace) => {
     const { specifier, containingFilePath } = input;
     if (!containingFilePath || IGNORED_RUNTIME_DEPENDENCIES.has(specifier))
         return;
     if (isBinary(input)) {
         const binaryName = fromBinary(input);
         const inputWorkspace = getWorkspaceFor(input, chief, workspace);
-        const isHandled = deputy.maybeAddReferencedBinary(inputWorkspace, binaryName);
-        if (isHandled || input.optional)
+        const dependencies = deputy.maybeAddReferencedBinary(inputWorkspace, binaryName);
+        if (dependencies) {
+            for (const dependency of dependencies) {
+                addExternalRef(externalRefs, containingFilePath, { specifier: dependency, identifier: binaryName });
+            }
+            return;
+        }
+        if (dependencies || input.optional)
             return;
         addIssue({
             type: 'binaries',
@@ -33,9 +44,12 @@ export const getReferencedInputsHandler = (deputy, chief, isGitIgnored, addIssue
         const inputWorkspace = getWorkspaceFor(input, chief, workspace);
         if (inputWorkspace) {
             const isHandled = deputy.maybeAddReferencedExternalDependency(inputWorkspace, packageName);
+            if (!isWorkspace) {
+                addExternalRef(externalRefs, containingFilePath, { specifier: packageName, identifier: undefined });
+            }
             if (isWorkspace || isDependency(input)) {
                 if (!isHandled) {
-                    if (!input.optional && ((deputy.isProduction && input.production) || !deputy.isProduction)) {
+                    if (!input.optional && ((options.isProduction && input.production) || !options.isProduction)) {
                         addIssue({
                             type: 'unlisted',
                             filePath: containingFilePath,
@@ -87,7 +101,7 @@ export const getReferencedInputsHandler = (deputy, chief, isGitIgnored, addIssue
             });
         }
         else {
-            debugLog(workspace.name, `Unable to resolve ${toDebugString(input, chief.cwd)}`);
+            debugLog(workspace.name, `Unable to resolve ${toDebugString(input, options.cwd)}`);
         }
     }
 };

package/dist/util/create-options.d.ts

@@ -1,7 +1,7 @@
 import type { Options } from '../types/options.js';
 import type { ParsedCLIArgs } from './cli-arguments.js';
 interface CreateOptions extends Partial<Options> {
-    parsedCLIArgs?: ParsedCLIArgs;
+    args?: ParsedCLIArgs;
 }
 export declare const createOptions: (options: CreateOptions) => Promise<{
     cacheLocation: string;
@@ -1327,6 +1327,7 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
         _files: import("../types/issues.js").IssueSeverity;
     };
     tags: import("../types/options.js").Tags;
+    traceDependency: string | undefined;
     traceExport: string | undefined;
     traceFile: string | undefined;
     tsConfigFile: string | undefined;

package/dist/util/create-options.js

@@ -13,25 +13,25 @@ import { isAbsolute, join, normalize, toAbsolute, toPosix } from './path.js';
 import { splitTags } from './tag.js';
 const pcwd = process.cwd();
 export const createOptions = async (options) => {
-    const { parsedCLIArgs = {} } = options;
-    const cwd = normalize(toPosix(toAbsolute(options.cwd ?? parsedCLIArgs.directory ?? pcwd, pcwd)));
+    const { args = {} } = options;
+    const cwd = normalize(toPosix(toAbsolute(options.cwd ?? args.directory ?? pcwd, pcwd)));
     const manifestPath = findFile(cwd, 'package.json');
     const manifest = manifestPath && (await loadJSON(manifestPath));
     if (!(manifestPath && manifest)) {
         throw new ConfigurationError('Unable to find package.json');
     }
     let configFilePath;
-    for (const configPath of parsedCLIArgs.config ? [parsedCLIArgs.config] : KNIP_CONFIG_LOCATIONS) {
+    for (const configPath of args.config ? [args.config] : KNIP_CONFIG_LOCATIONS) {
         const resolvedConfigFilePath = isAbsolute(configPath) ? configPath : findFile(cwd, configPath);
         if (resolvedConfigFilePath) {
             configFilePath = resolvedConfigFilePath;
             break;
         }
     }
-    if (parsedCLIArgs.config && !configFilePath && !manifest.knip) {
-        throw new ConfigurationError(`Unable to find ${parsedCLIArgs.config} or package.json#knip`);
+    if (args.config && !configFilePath && !manifest.knip) {
+        throw new ConfigurationError(`Unable to find ${args.config} or package.json#knip`);
     }
-    const loadedConfig = Object.assign({}, manifest.knip, configFilePath ? await loadResolvedConfigFile(configFilePath, parsedCLIArgs) : {});
+    const loadedConfig = Object.assign({}, manifest.knip, configFilePath ? await loadResolvedConfigFile(configFilePath, args) : {});
     const parsedConfig = knipConfigurationSchema.parse(partitionCompilers(loadedConfig));
     if (!configFilePath && manifest.knip)
         configFilePath = manifestPath;
@@ -43,58 +43,58 @@ export const createOptions = async (options) => {
                 ? manifest.workspaces
                 : (manifest.workspaces.packages ?? [])
             : []);
-    const isStrict = options.isStrict ?? parsedCLIArgs.strict ?? false;
-    const isProduction = options.isProduction ?? parsedCLIArgs.production ?? isStrict;
-    const isDebug = parsedCLIArgs.debug ?? false;
-    const isTrace = Boolean(parsedCLIArgs.trace ?? parsedCLIArgs['trace-file'] ?? parsedCLIArgs['trace-export']);
+    const isStrict = options.isStrict ?? args.strict ?? false;
+    const isProduction = options.isProduction ?? args.production ?? isStrict;
+    const isDebug = args.debug ?? false;
+    const isTrace = Boolean(args.trace ?? args['trace-file'] ?? args['trace-export'] ?? args['trace-dependency']);
     const rules = { ...defaultRules, ...parsedConfig.rules };
     const excludesFromRules = getKeysByValue(rules, 'off');
     const includedIssueTypes = getIncludedIssueTypes({
         isProduction,
         exclude: [...excludesFromRules, ...(parsedConfig.exclude ?? [])],
         include: parsedConfig.include ?? [],
-        excludeOverrides: options.excludedIssueTypes ?? parsedCLIArgs.exclude ?? [],
+        excludeOverrides: options.excludedIssueTypes ?? args.exclude ?? [],
         includeOverrides: [
-            ...(options.includedIssueTypes ?? parsedCLIArgs.include ?? []),
-            ...(parsedCLIArgs.dependencies ? shorthandDeps : []),
-            ...(parsedCLIArgs.exports ? shorthandExports : []),
-            ...(parsedCLIArgs.files ? shorthandFiles : []),
+            ...(options.includedIssueTypes ?? args.include ?? []),
+            ...(args.dependencies ? shorthandDeps : []),
+            ...(args.exports ? shorthandExports : []),
+            ...(args.files ? shorthandFiles : []),
         ],
     });
     for (const [key, value] of Object.entries(includedIssueTypes)) {
         if (!value)
             rules[key] = 'off';
     }
-    const fixTypes = options.fixTypes ?? parsedCLIArgs['fix-type'] ?? [];
-    const isFixFiles = parsedCLIArgs['allow-remove-files'] && (fixTypes.length === 0 || fixTypes.includes('files'));
-    const isIncludeLibs = parsedCLIArgs['include-libs'] ?? options.isIncludeLibs ?? false;
+    const fixTypes = options.fixTypes ?? args['fix-type'] ?? [];
+    const isFixFiles = args['allow-remove-files'] && (fixTypes.length === 0 || fixTypes.includes('files'));
+    const isIncludeLibs = args['include-libs'] ?? options.isIncludeLibs ?? false;
     const isReportClassMembers = includedIssueTypes.classMembers;
-    const tags = splitTags(parsedCLIArgs.tags ?? options.tags ?? parsedConfig.tags ?? parsedCLIArgs['experimental-tags'] ?? []);
+    const tags = splitTags(args.tags ?? options.tags ?? parsedConfig.tags ?? args['experimental-tags'] ?? []);
     return {
-        cacheLocation: parsedCLIArgs['cache-location'] ?? join(cwd, 'node_modules', '.cache', 'knip'),
+        cacheLocation: args['cache-location'] ?? join(cwd, 'node_modules', '.cache', 'knip'),
         catalog: await getCatalogContainer(cwd, manifest, manifestPath, pnpmWorkspacePath, pnpmWorkspace),
-        config: parsedCLIArgs.config,
+        config: args.config,
         configFilePath,
         cwd,
-        dependencies: parsedCLIArgs.dependencies ?? false,
+        dependencies: args.dependencies ?? false,
         experimentalTags: tags,
-        exports: parsedCLIArgs.exports ?? false,
-        files: parsedCLIArgs.files ?? false,
+        exports: args.exports ?? false,
+        files: args.files ?? false,
         fixTypes,
-        gitignore: parsedCLIArgs['no-gitignore'] ? false : (options.gitignore ?? true),
+        gitignore: args['no-gitignore'] ? false : (options.gitignore ?? true),
         includedIssueTypes,
-        isCache: parsedCLIArgs.cache ?? false,
+        isCache: args.cache ?? false,
         isDebug,
-        isDisableConfigHints: parsedCLIArgs['no-config-hints'] || isProduction || Boolean(parsedCLIArgs.workspace),
-        isFix: parsedCLIArgs.fix ?? options.isFix ?? isFixFiles ?? fixTypes.length > 0,
+        isDisableConfigHints: args['no-config-hints'] || isProduction || Boolean(args.workspace),
+        isFix: args.fix ?? options.isFix ?? isFixFiles ?? fixTypes.length > 0,
         isFixCatalog: fixTypes.length === 0 || fixTypes.includes('catalog'),
         isFixDependencies: fixTypes.length === 0 || fixTypes.includes('dependencies'),
         isFixFiles,
         isFixUnusedExports: fixTypes.length === 0 || fixTypes.includes('exports'),
         isFixUnusedTypes: fixTypes.length === 0 || fixTypes.includes('types'),
-        isFormat: parsedCLIArgs.format ?? options.isFormat ?? false,
-        isIncludeEntryExports: parsedCLIArgs['include-entry-exports'] ?? options.isIncludeEntryExports ?? false,
-        isIsolateWorkspaces: options.isIsolateWorkspaces ?? parsedCLIArgs['isolate-workspaces'] ?? false,
+        isFormat: args.format ?? options.isFormat ?? false,
+        isIncludeEntryExports: args['include-entry-exports'] ?? options.isIncludeEntryExports ?? false,
+        isIsolateWorkspaces: options.isIsolateWorkspaces ?? args['isolate-workspaces'] ?? false,
         isProduction,
         isReportClassMembers,
         isReportDependencies: includedIssueTypes.dependencies ||
@@ -106,24 +106,25 @@ export const createOptions = async (options) => {
         isSession: options.isSession ?? false,
         isShowProgress: !isDebug &&
             !isTrace &&
-            parsedCLIArgs['no-progress'] !== true &&
+            args['no-progress'] !== true &&
             options.isShowProgress !== false &&
             process.stdout.isTTY &&
             typeof process.stdout.cursorTo === 'function',
         isSkipLibs: !(isIncludeLibs || includedIssueTypes.classMembers),
         isStrict,
         isTrace,
-        isTreatConfigHintsAsErrors: parsedCLIArgs['treat-config-hints-as-errors'] ?? parsedConfig.treatConfigHintsAsErrors ?? false,
-        isUseTscFiles: options.isUseTscFiles ?? parsedCLIArgs['use-tsconfig-files'] ?? (options.isSession && !configFilePath),
-        isWatch: parsedCLIArgs.watch ?? options.isWatch ?? false,
-        maxShowIssues: parsedCLIArgs['max-show-issues'] ? Number(parsedCLIArgs['max-show-issues']) : undefined,
+        isTreatConfigHintsAsErrors: args['treat-config-hints-as-errors'] ?? parsedConfig.treatConfigHintsAsErrors ?? false,
+        isUseTscFiles: options.isUseTscFiles ?? args['use-tsconfig-files'] ?? (options.isSession && !configFilePath),
+        isWatch: args.watch ?? options.isWatch ?? false,
+        maxShowIssues: args['max-show-issues'] ? Number(args['max-show-issues']) : undefined,
         parsedConfig,
         rules,
         tags,
-        traceExport: parsedCLIArgs['trace-export'],
-        traceFile: parsedCLIArgs['trace-file'] ? toAbsolute(parsedCLIArgs['trace-file'], cwd) : undefined,
-        tsConfigFile: parsedCLIArgs.tsConfig,
-        workspace: options.workspace ?? parsedCLIArgs.workspace,
+        traceDependency: args['trace-dependency'],
+        traceExport: args['trace-export'],
+        traceFile: args['trace-file'] ? toAbsolute(args['trace-file'], cwd) : undefined,
+        tsConfigFile: args.tsConfig,
+        workspace: options.workspace ?? args.workspace,
         workspaces,
     };
 };

package/dist/util/module-graph.d.ts

@@ -1,5 +1,6 @@
 import type { FileNode, IdToFileMap, IdToNsToFileMap, ImportMap, ImportMaps, ModuleGraph } from '../types/module-graph.js';
 export declare const updateImportMap: (file: FileNode, importMap: ImportMap, graph: ModuleGraph) => void;
+export declare const createFileNode: () => FileNode;
 export declare const createImports: () => ImportMaps;
 export declare const addValue: (map: IdToFileMap, id: string, value: string) => void;
 export declare const addNsValue: (map: IdToNsToFileMap, id: string, ns: string, value: string) => void;

package/dist/util/module-graph.js

@@ -28,10 +28,11 @@ export const updateImportMap = (file, importMap, graph) => {
         graph.set(importedFilePath, importedFile);
     }
 };
-const createFileNode = () => ({
+export const createFileNode = () => ({
     imports: {
         internal: new Map(),
         external: new Set(),
+        externalRefs: new Set(),
         unresolved: new Set(),
         programFiles: new Set(),
         entryFiles: new Set(),

package/dist/util/trace.d.ts

@@ -1,2 +1,2 @@
-import type { TreeNode } from '../graph-explorer/operations/build-exports-tree.js';
-export declare const formatTrace: (node: TreeNode, toRelative: (path: string) => string, isReferenced: boolean) => string;
+import type { ExportsTreeNode } from '../graph-explorer/operations/build-exports-tree.js';
+export declare const formatTrace: (node: ExportsTreeNode, toRelative: (path: string) => string, isReferenced: boolean) => string;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.75.1";
+export declare const version = "5.76.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.75.1';
+export const version = '5.76.0';

package/package.json

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

package/dist/util/get-referenced-inputs.d.ts

@@ -1,5 +0,0 @@
-import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
-import type { DependencyDeputy } from '../DependencyDeputy.js';
-import type { Issue } from '../types/issues.js';
-import { type Input } from './input.js';
-export declare const getReferencedInputsHandler: (deputy: DependencyDeputy, chief: ConfigurationChief, isGitIgnored: (s: string) => boolean, addIssue: (issue: Issue) => void) => (input: Input, workspace: Workspace) => string | undefined;