knip 5.76.1 → 5.76.3

package/dist/DependencyDeputy.d.ts

@@ -6,13 +6,14 @@ import type { MainOptions } from './util/create-options.js';
 export declare class DependencyDeputy {
     isProduction: boolean;
     isStrict: boolean;
+    isReportDependencies: boolean;
     _manifests: WorkspaceManifests;
     referencedDependencies: Map<string, Set<string>>;
     referencedBinaries: Map<string, Set<string>>;
     hostDependencies: Map<string, HostDependencies>;
     installedBinaries: Map<string, InstalledBinaries>;
     hasTypesIncluded: Map<string, Set<string>>;
-    constructor({ isProduction, isStrict }: MainOptions);
+    constructor({ isProduction, isStrict, isReportDependencies }: MainOptions);
     addWorkspace({ name, cwd, dir, manifestPath, manifestStr, manifest, ignoreDependencies: id, ignoreBinaries: ib, ignoreUnresolved: iu, }: {
         name: string;
         cwd: string;

package/dist/DependencyDeputy.js

@@ -8,15 +8,17 @@ const filterIsProduction = (id, isProduction) => typeof id === 'string' ? (isPro
 export class DependencyDeputy {
     isProduction;
     isStrict;
+    isReportDependencies;
     _manifests = new Map();
     referencedDependencies;
     referencedBinaries;
     hostDependencies;
     installedBinaries;
     hasTypesIncluded;
-    constructor({ isProduction, isStrict }) {
+    constructor({ isProduction, isStrict, isReportDependencies }) {
         this.isProduction = isProduction;
         this.isStrict = isStrict;
+        this.isReportDependencies = isReportDependencies;
         this.referencedDependencies = new Map();
         this.referencedBinaries = new Map();
         this.hostDependencies = new Map();
@@ -39,14 +41,16 @@ export class DependencyDeputy {
             ...(this.isStrict ? peerDependencies : []),
             ...(this.isProduction ? [] : devDependencies),
         ];
-        const { hostDependencies, installedBinaries, hasTypesIncluded } = getDependencyMetaData({
-            packageNames,
-            dir,
-            cwd,
-        });
-        this.setHostDependencies(name, hostDependencies);
-        this.setInstalledBinaries(name, installedBinaries);
-        this.setHasTypesIncluded(name, hasTypesIncluded);
+        if (this.isReportDependencies) {
+            const { hostDependencies, installedBinaries, hasTypesIncluded } = getDependencyMetaData({
+                packageNames,
+                dir,
+                cwd,
+            });
+            this.setHostDependencies(name, hostDependencies);
+            this.setInstalledBinaries(name, installedBinaries);
+            this.setHasTypesIncluded(name, hasTypesIncluded);
+        }
         const ignoreDependencies = id.flatMap(id => filterIsProduction(id, this.isProduction)).map(toRegexOrString);
         const ignoreBinaries = ib.flatMap(ib => filterIsProduction(ib, this.isProduction)).map(toRegexOrString);
         const ignoreUnresolved = iu.map(toRegexOrString);
@@ -124,6 +128,8 @@ export class DependencyDeputy {
         return manifest.optionalPeerDependencies;
     }
     maybeAddReferencedExternalDependency(workspace, packageName) {
+        if (!this.isReportDependencies)
+            return true;
         if (isBuiltin(packageName))
             return true;
         if (IGNORED_RUNTIME_DEPENDENCIES.has(packageName))
@@ -145,6 +151,8 @@ export class DependencyDeputy {
         return false;
     }
     maybeAddReferencedBinary(workspace, binaryName) {
+        if (!this.isReportDependencies)
+            return new Set();
         if (IGNORED_GLOBAL_BINARIES.has(binaryName))
             return new Set();
         this.addReferencedBinary(workspace.name, binaryName);

package/dist/WorkspaceWorker.d.ts

@@ -13,6 +13,7 @@ type WorkspaceManagerOptions = {
     config: WorkspaceConfiguration;
     manifest: PackageJson;
     dependencies: DependencySet;
+    rootManifest: PackageJson | undefined;
     handleInput: HandleInput;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
     getSourceFile: GetSourceFile;
@@ -32,6 +33,7 @@ export declare class WorkspaceWorker {
     dir: string;
     config: WorkspaceConfiguration;
     manifest: PackageJson;
+    rootManifest: PackageJson | undefined;
     dependencies: DependencySet;
     handleInput: HandleInput;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
@@ -44,7 +46,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, handleInput, findWorkspaceByFilePath, getSourceFile, configFilesMap, options, }: WorkspaceManagerOptions);
+    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getSourceFile, configFilesMap, options, }: WorkspaceManagerOptions);
     init(): Promise<void>;
     private determineEnabledPlugins;
     private getConfigForPlugin;

package/dist/WorkspaceWorker.js

@@ -21,6 +21,7 @@ export class WorkspaceWorker {
     dir;
     config;
     manifest;
+    rootManifest;
     dependencies;
     handleInput;
     findWorkspaceByFilePath;
@@ -33,11 +34,12 @@ export class WorkspaceWorker {
     enabledPluginsInAncestors;
     cache;
     configFilesMap;
-    constructor({ name, dir, config, manifest, dependencies, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getSourceFile, configFilesMap, options, }) {
+    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getSourceFile, configFilesMap, options, }) {
         this.name = name;
         this.dir = dir;
         this.config = config;
         this.manifest = manifest;
+        this.rootManifest = rootManifest;
         this.dependencies = dependencies;
         this.negatedWorkspacePatterns = negatedWorkspacePatterns;
         this.ignoredWorkspacePatterns = ignoredWorkspacePatterns;
@@ -158,7 +160,8 @@ export class WorkspaceWorker {
         const isProduction = this.options.isProduction;
         const knownBinsOnly = false;
         const manifestScriptNames = new Set(Object.keys(manifest.scripts ?? {}));
-        const baseOptions = { manifestScriptNames, cwd, rootCwd, containingFilePath, knownBinsOnly };
+        const rootManifest = this.rootManifest;
+        const baseOptions = { manifestScriptNames, rootManifest, cwd, rootCwd, containingFilePath, knownBinsOnly };
         const baseScriptOptions = { ...baseOptions, manifest, isProduction, enabledPlugins: this.enabledPlugins };
         const [productionScripts, developmentScripts] = getFilteredScripts(manifest.scripts ?? {});
         const inputsFromManifest = _getInputsFromScripts(Object.values(developmentScripts), baseOptions);

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

@@ -1,7 +1,7 @@
 import parseArgs from 'minimist';
-import { isFile } from '../../util/fs.js';
 import { toEntry } from '../../util/input.js';
 import { isAbsolute, join } from '../../util/path.js';
+import { _resolveSync } from '../../util/resolve.js';
 import { resolveX } from './bunx.js';
 const commands = [
     'add',
@@ -46,9 +46,12 @@ export const resolve = (_binary, args, options) => {
     if (command !== 'run' && commands.includes(command))
         return [];
     const filePath = command === 'run' ? script : command;
-    const absFilePath = isAbsolute(filePath) ? filePath : join(cwd, filePath);
-    if (isFile(absFilePath))
-        return [toEntry(absFilePath)];
+    if (!filePath)
+        return [];
+    const _cwd = parsed.cwd ? join(cwd, parsed.cwd) : cwd;
+    const resolved = _resolveSync(isAbsolute(filePath) ? filePath : join(_cwd, filePath), _cwd);
+    if (resolved)
+        return [toEntry(resolved)];
     const dir = parsed.cwd ? join(cwd, parsed.cwd) : undefined;
     const opts = dir ? { cwd: dir } : {};
     return command === 'run' ? [] : fromArgs(args, opts);

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

@@ -1,17 +1,20 @@
 import parseArgs from 'minimist';
-import { toDependency } from '../../util/input.js';
+import { toBinary, toDependency } from '../../util/input.js';
 import { stripVersionFromSpecifier } from '../../util/modules.js';
+import { isInternal } from '../../util/path.js';
 import { argsFrom } from '../util.js';
 export const resolveX = (args, options) => {
     const { fromArgs } = options;
-    const parsed = parseArgs(args);
+    const parsed = parseArgs(args, { boolean: ['bun'] });
     const packageSpecifier = parsed._[0];
     const specifier = packageSpecifier ? stripVersionFromSpecifier(packageSpecifier) : '';
     const packages = parsed.package && !parsed.yes ? [parsed.package].flat().map(stripVersionFromSpecifier) : [];
     const command = parsed['shell-mode'] ? fromArgs([parsed['shell-mode']]) : [];
     const restArgs = argsFrom(args, packageSpecifier);
-    const dependency = specifier ? [toDependency(specifier, { optional: true })] : [];
-    return [...dependency, ...packages.map(id => toDependency(id)), ...command, ...fromArgs(restArgs).slice(1)];
+    const isBinary = specifier && !packageSpecifier.includes('@') && !isInternal(specifier);
+    const dependency = isBinary ? toBinary(specifier, { optional: true }) : toDependency(specifier, { optional: true });
+    const specifiers = specifier ? [dependency] : [];
+    return [...specifiers, ...packages.map(id => toDependency(id)), ...command, ...fromArgs(restArgs).slice(1)];
 };
 export const resolve = (_binary, args, options) => {
     return resolveX(args, options);

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

@@ -1,7 +1,12 @@
 import parseArgs from 'minimist';
 export const resolve = (_binary, args, options) => {
-    const { fromArgs } = options;
-    const parsed = parseArgs(args);
-    const [command] = parsed._;
-    return command !== 'exec' ? [] : fromArgs(parsed._.slice(1));
+    const { fromArgs, manifestScriptNames } = options;
+    const parsed = parseArgs(args, { '--': true });
+    const [command, script] = parsed._;
+    const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--']) : [];
+    if (command === 'exec')
+        return _childArgs;
+    if (command === 'run' && manifestScriptNames.has(script))
+        return _childArgs;
+    return [];
 };

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

@@ -64,6 +64,7 @@ export const resolve = (_binary, args, options) => {
     const parsed = parseArgs(args, {
         boolean: ['recursive', 'silent', 'shell-mode'],
         alias: { recursive: 'r', silent: 's', 'shell-mode': 'c', filter: 'F' },
+        '--': true,
     });
     const [command] = parsed._;
     if (command === 'dlx') {
@@ -73,9 +74,12 @@ export const resolve = (_binary, args, options) => {
     const { manifestScriptNames, fromArgs } = options;
     if (parsed.filter && !parsed.recursive)
         return [];
-    if (manifestScriptNames.has(command) || commands.includes(command))
-        return [];
-    if (command === 'exec')
-        return fromArgs(parsed._.slice(1));
+    const childInputs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--']) : [];
+    if (command === 'exec') {
+        return childInputs.length > 0 ? childInputs : fromArgs(parsed._.slice(1));
+    }
+    const isScript = manifestScriptNames.has(command);
+    if (isScript || commands.includes(command))
+        return childInputs;
     return command ? [toBinary(command)] : [];
 };

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

@@ -50,18 +50,19 @@ const resolveDlx = (args, options) => {
 };
 export const resolve = (_binary, args, options) => {
     const { manifestScriptNames, fromArgs, cwd, rootCwd } = options;
-    const parsed = parseArgs(args, { boolean: ['top-level'], string: ['cwd'] });
+    const parsed = parseArgs(args, { boolean: ['top-level'], string: ['cwd'], '--': true });
     const dir = parsed['top-level'] ? rootCwd : parsed.cwd ? join(cwd, parsed.cwd) : undefined;
     const [command, binary] = parsed._;
     if (!command && !binary)
         return [];
+    const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--']) : [];
     if (command === 'run') {
         if (manifestScriptNames.has(binary))
-            return [];
+            return _childArgs;
         const bin = toBinary(binary, { optional: true });
         if (dir)
             Object.assign(bin, { dir });
-        return [bin];
+        return [bin, ..._childArgs];
     }
     if (command === 'node')
         return fromArgs(parsed._);
@@ -70,7 +71,7 @@ export const resolve = (_binary, args, options) => {
         return resolveDlx(argsForDlx, options);
     }
     if ((!dir && manifestScriptNames.has(command)) || commands.includes(command))
-        return [];
+        return _childArgs;
     const opts = dir ? { cwd: dir } : {};
     return fromArgs(argsFrom(args, command === 'exec' ? binary : command), opts);
 };

package/dist/cli.js

@@ -30,7 +30,7 @@ const run = async () => {
             console.log(version);
             process.exit(0);
         }
-        const { issues, counters, tagHints, configurationHints, includedWorkspaceDirs } = await main(options);
+        const { issues, counters, tagHints, configurationHints, includedWorkspaceDirs, enabledPlugins } = await main(options);
         if (options.isWatch || options.isTrace)
             return;
         const initialData = {
@@ -39,6 +39,7 @@ const run = async () => {
             counters,
             tagHints,
             configurationHints,
+            enabledPlugins,
             includedWorkspaceDirs,
             cwd: options.cwd,
             configFilePath: options.configFilePath,

package/dist/graph/analyze.js

@@ -199,8 +199,11 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                 }
             }
         }
-        const unusedFiles = [...unreferencedFiles].filter(filePath => !analyzedFiles.has(filePath));
-        collector.addFilesIssues(unusedFiles);
+        const unusedFiles = options.isReportFiles
+            ? [...unreferencedFiles].filter(filePath => !analyzedFiles.has(filePath))
+            : [];
+        if (options.isReportFiles)
+            collector.addFilesIssues(unusedFiles);
         collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
         if (options.isReportDependencies) {
             const { dependencyIssues, devDependencyIssues, optionalPeerDependencyIssues } = deputy.settleDependencyIssues();

package/dist/graph/build.d.ts

@@ -24,5 +24,6 @@ export declare function build({ chief, collector, counselor, deputy, factory, is
     analyzedFiles: Set<string>;
     unreferencedFiles: Set<string>;
     analyzeSourceFile: (filePath: string, principal: ProjectPrincipal) => void;
+    enabledPluginsStore: Map<string, string[]>;
 }>;
 export {};

package/dist/graph/build.js

@@ -20,8 +20,9 @@ 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 externalRefsFromInputs = new Map();
+    const externalRefsFromInputs = options.isSession ? new Map() : undefined;
     const handleInput = createInputHandler(deputy, chief, isGitIgnored, addIssue, externalRefsFromInputs, options);
+    const rootManifest = chief.getManifestForWorkspace('.');
     for (const workspace of workspaces) {
         const { name, dir, manifestPath, manifestStr } = workspace;
         const manifest = chief.getManifestForWorkspace(name);
@@ -62,6 +63,7 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
             config,
             manifest,
             dependencies,
+            rootManifest,
             handleInput: (input) => handleInput(input, workspace),
             findWorkspaceByFilePath: chief.findWorkspaceByFilePath.bind(chief),
             negatedWorkspacePatterns: chief.getNegatedWorkspacePatterns(name),
@@ -255,6 +257,7 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
         isFixExports: options.isFixUnusedExports,
         isFixTypes: options.isFixUnusedTypes,
         isReportClassMembers: options.isReportClassMembers,
+        isReportExports: options.isReportExports,
         skipTypeOnly: options.isStrict,
         tags: options.tags,
     };
@@ -316,6 +319,7 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                     containingFilePath: filePath,
                     dependencies,
                     manifestScriptNames,
+                    rootManifest,
                 };
                 const inputs = _getInputsFromScripts(file.scripts, opts);
                 for (const input of inputs) {
@@ -327,7 +331,7 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                 }
             }
             file.imports.unresolved = unresolvedImports;
-            const pluginRefs = externalRefsFromInputs.get(filePath);
+            const pluginRefs = externalRefsFromInputs?.get(filePath);
             if (pluginRefs)
                 for (const ref of pluginRefs)
                     file.imports.externalRefs.add(ref);
@@ -385,11 +389,13 @@ 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);
+    if (externalRefsFromInputs) {
+        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,
@@ -397,5 +403,6 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
         analyzedFiles,
         unreferencedFiles,
         analyzeSourceFile,
+        enabledPluginsStore,
     };
 }

package/dist/index.d.ts

@@ -5,4 +5,7 @@ export declare const main: (options: MainOptions) => Promise<{
     tagHints: Set<import("./types/issues.js").TagHint>;
     configurationHints: Set<import("./types/issues.js").ConfigurationHint>;
     includedWorkspaceDirs: string[];
+    enabledPlugins: {
+        [k: string]: string[];
+    };
 }>;

package/dist/plugins/bun/index.js

@@ -2,17 +2,16 @@ import parseArgs from 'minimist';
 import { toEntry } from '../../util/input.js';
 const title = 'Bun';
 const enablers = ['bun'];
-const isEnabled = () => true;
-const config = ['package.json'];
-const packageJsonPath = (id) => id;
-const resolveConfig = localConfig => {
-    const scripts = localConfig.scripts;
-    if (scripts) {
-        const testScripts = Object.keys(scripts).filter(script => /(?<=^|\s)bun test/.test(scripts[script]));
-        for (const script of testScripts) {
-            const parsed = parseArgs(scripts[script].split(' '));
+const hasBunTest = (scripts) => scripts && Object.values(scripts).some(script => /(?<=^|\s)bun test/.test(script));
+const isEnabled = ({ manifest }) => !!hasBunTest(manifest.scripts);
+const patterns = ['**/*.{test,spec}.{js,jsx,ts,tsx}', '**/*_{test,spec}.{js,jsx,ts,tsx}'];
+const resolve = (options) => {
+    const scripts = { ...options.rootManifest?.scripts, ...options.manifest.scripts };
+    for (const script of Object.values(scripts)) {
+        if (/(?<=^|\s)bun test/.test(script)) {
+            const parsed = parseArgs(script.split(' '));
             if (parsed._.filter(id => id !== 'bun' && id !== 'test').length === 0) {
-                return ['**/*.{test,spec}.{js,jsx,ts,tsx}', '**/*_{test,spec}.{js,jsx,ts,tsx}'].map(toEntry);
+                return patterns.map(toEntry);
             }
         }
     }
@@ -22,8 +21,6 @@ const plugin = {
     title,
     enablers,
     isEnabled,
-    config,
-    packageJsonPath,
-    resolveConfig,
+    resolve,
 };
 export default plugin;

package/dist/plugins/node/index.js

@@ -1,19 +1,18 @@
 import { toEntry, toProductionEntry } from '../../util/input.js';
 const title = 'Node.js';
 const isEnabled = () => true;
-const config = ['package.json'];
-const packageJsonPath = (id) => id;
-const resolveConfig = localConfig => {
-    const scripts = localConfig.scripts;
-    const entries = [toProductionEntry('server.js')];
-    if (scripts && Object.values(scripts).some(script => /(?<=^|\s)node\s(.*)--test/.test(script))) {
-        const patterns = [
-            '**/*{.,-,_}test.{cjs,mjs,js,cts,mts,ts}',
-            '**/test-*.{cjs,mjs,js,cts,mts,ts}',
-            '**/test.{cjs,mjs,js,cts,mts,ts}',
-            '**/test/**/*.{cjs,mjs,js,cts,mts,ts}',
-        ];
-        entries.push(...patterns.map(id => toEntry(id)));
+const patterns = [
+    '**/*{.,-,_}test.{cjs,mjs,js,cts,mts,ts}',
+    '**/test-*.{cjs,mjs,js,cts,mts,ts}',
+    '**/test.{cjs,mjs,js,cts,mts,ts}',
+    '**/test/**/*.{cjs,mjs,js,cts,mts,ts}',
+];
+const hasNodeTest = (scripts) => scripts && Object.values(scripts).some(script => /(?<=^|\s)node\s(.*)--test/.test(script));
+const entry = ['server.js'];
+const resolve = (options) => {
+    const entries = entry.map(id => toProductionEntry(id));
+    if (hasNodeTest(options.manifest.scripts) || hasNodeTest(options.rootManifest?.scripts)) {
+        entries.push(...patterns.map(toEntry));
     }
     return entries;
 };
@@ -39,9 +38,8 @@ const args = {
 const plugin = {
     title,
     isEnabled,
-    packageJsonPath,
-    config,
-    resolveConfig,
+    entry,
+    resolve,
     args,
 };
 export default plugin;

package/dist/plugins/nx/index.d.ts

@@ -1,3 +1,6 @@
 import type { Plugin } from '../../types/config.js';
+export declare const docs: {
+    note: string;
+};
 declare const plugin: Plugin;
 export default plugin;

package/dist/plugins/nx/index.js

@@ -51,6 +51,9 @@ const resolveConfig = async (localConfig, options) => {
 const args = {
     fromArgs: (parsed) => (parsed._[0] === 'exec' ? parsed._.slice(1) : []),
 };
+export const docs = {
+    note: `Also see [integrated monorepos](/features/integrated-monorepos) and the note regarding internal workspace dependencies.`,
+};
 const plugin = {
     title,
     enablers,

package/dist/reporters/util/configuration-hints.d.ts

@@ -19,4 +19,4 @@ export declare const finalizeConfigurationHints: (results: Results, options: {
     cwd: string;
     configFilePath?: string;
 }) => ProcessedHint[];
-export declare const printConfigurationHints: ({ cwd, counters, issues, tagHints, configurationHints, isTreatConfigHintsAsErrors, includedWorkspaceDirs, configFilePath, }: ReporterOptions) => void;
+export declare const printConfigurationHints: ({ cwd, counters, issues, tagHints, configurationHints, enabledPlugins, isTreatConfigHintsAsErrors, includedWorkspaceDirs, configFilePath, }: ReporterOptions) => void;

package/dist/reporters/util/configuration-hints.js

@@ -102,8 +102,8 @@ export const finalizeConfigurationHints = (results, options) => {
         return row;
     }));
 };
-export const printConfigurationHints = ({ cwd, counters, issues, tagHints, configurationHints, isTreatConfigHintsAsErrors, includedWorkspaceDirs, configFilePath, }) => {
-    const rows = finalizeConfigurationHints({ issues, counters, configurationHints, tagHints, includedWorkspaceDirs }, { cwd, configFilePath });
+export const printConfigurationHints = ({ cwd, counters, issues, tagHints, configurationHints, enabledPlugins, isTreatConfigHintsAsErrors, includedWorkspaceDirs, configFilePath, }) => {
+    const rows = finalizeConfigurationHints({ issues, counters, configurationHints, tagHints, includedWorkspaceDirs, enabledPlugins }, { cwd, configFilePath });
     if (rows.length > 0) {
         const getTitle = isTreatConfigHintsAsErrors ? getColoredTitle : getDimmedTitle;
         console.log(getTitle('Configuration hints', configurationHints.size));

package/dist/run.d.ts

@@ -8,6 +8,9 @@ export declare const run: (options: MainOptions) => Promise<{
         tagHints: Set<import("./types/issues.js").TagHint>;
         configurationHints: Set<import("./types/issues.js").ConfigurationHint>;
         includedWorkspaceDirs: string[];
+        enabledPlugins: {
+            [k: string]: string[];
+        };
     };
     session: {
         listener: import("fs").WatchListener<string | Buffer<ArrayBufferLike>>;

package/dist/run.js

@@ -29,7 +29,7 @@ export const run = async (options) => {
     collector.setIgnoreIssues(chief.config.ignoreIssues);
     debugLogObject('*', 'Included workspaces', () => workspaces.map(w => w.pkgName));
     debugLogObject('*', 'Included workspace configs', () => workspaces.map(w => ({ pkgName: w.pkgName, name: w.name, config: w.config, ancestors: w.ancestors })));
-    const { graph, entryPaths, analyzedFiles, unreferencedFiles, analyzeSourceFile } = await build({
+    const { graph, entryPaths, analyzedFiles, unreferencedFiles, analyzeSourceFile, enabledPluginsStore } = await build({
         chief,
         collector,
         counselor,
@@ -100,6 +100,7 @@ export const run = async (options) => {
             tagHints,
             configurationHints,
             includedWorkspaceDirs: chief.includedWorkspaces.map(w => w.dir),
+            enabledPlugins: Object.fromEntries(enabledPluginsStore),
         },
         session,
         streamer,

package/dist/types/config.d.ts

@@ -33,6 +33,7 @@ export type GetImportsAndExportsOptions = {
     isFixExports: boolean;
     isFixTypes: boolean;
     isReportClassMembers: boolean;
+    isReportExports: boolean;
     tags: Tags;
 };
 export interface Configuration {
@@ -72,6 +73,7 @@ interface BaseOptions {
     rootCwd: string;
     cwd: string;
     manifestScriptNames: Set<string>;
+    rootManifest: PackageJson | undefined;
 }
 type IsPluginEnabledOptions = {
     cwd: string;

package/dist/types/issues.d.ts

@@ -55,6 +55,7 @@ export type ReporterOptions = {
     counters: Counters;
     tagHints: TagHints;
     configurationHints: Set<ConfigurationHint>;
+    enabledPlugins: Record<string, string[]>;
     isDisableConfigHints: boolean;
     isTreatConfigHintsAsErrors: boolean;
     cwd: string;

package/dist/typescript/get-imports-and-exports.d.ts

@@ -2,4 +2,4 @@ import ts from 'typescript';
 import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile } from '../types/config.js';
 import type { FileNode } from '../types/module-graph.js';
 import type { BoundSourceFile } from './SourceFile.js';
-export declare const _getImportsAndExports: (sourceFile: BoundSourceFile, resolveModule: (specifier: string) => ts.ResolvedModuleFull | undefined, typeChecker: ts.TypeChecker, options: GetImportsAndExportsOptions, ignoreExportsUsedInFile: IgnoreExportsUsedInFile, skipExports: boolean) => FileNode;
+export declare const _getImportsAndExports: (sourceFile: BoundSourceFile, resolveModule: (specifier: string) => ts.ResolvedModuleFull | undefined, typeChecker: ts.TypeChecker, options: GetImportsAndExportsOptions, ignoreExportsUsedInFile: IgnoreExportsUsedInFile, skipExportsForFile: boolean) => FileNode;

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

@@ -34,7 +34,8 @@ const createMember = (node, member, pos) => {
         flags: member.flags,
     };
 };
-const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, ignoreExportsUsedInFile, skipExports) => {
+const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, ignoreExportsUsedInFile, skipExportsForFile) => {
+    const skipExports = skipExportsForFile || !options.isReportExports;
     const internal = new Map();
     const external = new Set();
     const unresolved = new Set();
@@ -197,8 +198,6 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         }
     };
     const addExport = ({ node, symbol, identifier, type, pos, members, fix }) => {
-        if (skipExports)
-            return;
         let isReExport = Boolean(node.parent?.parent && ts.isExportDeclaration(node.parent.parent) && node.parent.parent.moduleSpecifier);
         if (symbol) {
             const importedSymbolFilePath = importedInternalSymbols.get(symbol);
@@ -266,9 +265,11 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                 const result = visitor(node, options);
                 result && (Array.isArray(result) ? result.forEach(addImportWithNode) : addImportWithNode(result));
             }
-            for (const visitor of visitors.export) {
-                const result = visitor(node, options);
-                result && (Array.isArray(result) ? result.forEach(addExport) : addExport(result));
+            if (!skipExports) {
+                for (const visitor of visitors.export) {
+                    const result = visitor(node, options);
+                    result && (Array.isArray(result) ? result.forEach(addExport) : addExport(result));
+                }
             }
             if (ts.isImportEqualsDeclaration(node) &&
                 ts.isQualifiedName(node.moduleReference) &&

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

@@ -5,4 +5,4 @@ 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;
+export declare const createInputHandler: (deputy: DependencyDeputy, chief: ConfigurationChief, isGitIgnored: (filePath: string) => boolean, addIssue: (issue: Issue) => void, externalRefs: ExternalRefsFromInputs | undefined, options: MainOptions) => (input: Input, workspace: Workspace) => string | undefined;

package/dist/util/create-input-handler.js

@@ -21,8 +21,10 @@ export const createInputHandler = (deputy, chief, isGitIgnored, addIssue, extern
         const inputWorkspace = getWorkspaceFor(input, chief, workspace);
         const dependencies = deputy.maybeAddReferencedBinary(inputWorkspace, binaryName);
         if (dependencies) {
-            for (const dependency of dependencies) {
-                addExternalRef(externalRefs, containingFilePath, { specifier: dependency, identifier: binaryName });
+            if (externalRefs) {
+                for (const dependency of dependencies) {
+                    addExternalRef(externalRefs, containingFilePath, { specifier: dependency, identifier: binaryName });
+                }
             }
             return;
         }
@@ -44,7 +46,7 @@ export const createInputHandler = (deputy, chief, isGitIgnored, addIssue, extern
         const inputWorkspace = getWorkspaceFor(input, chief, workspace);
         if (inputWorkspace) {
             const isHandled = deputy.maybeAddReferencedExternalDependency(inputWorkspace, packageName);
-            if (!isWorkspace) {
+            if (externalRefs && !isWorkspace) {
                 addExternalRef(externalRefs, containingFilePath, { specifier: packageName, identifier: undefined });
             }
             if (isWorkspace || isDependency(input)) {

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

@@ -31,6 +31,8 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
     isProduction: boolean;
     isReportClassMembers: boolean;
     isReportDependencies: boolean;
+    isReportExports: boolean;
+    isReportFiles: boolean;
     isReportTypes: boolean;
     isReportValues: boolean;
     isSession: boolean;

package/dist/util/create-options.js

@@ -101,6 +101,14 @@ export const createOptions = async (options) => {
             includedIssueTypes.unlisted ||
             includedIssueTypes.unresolved ||
             includedIssueTypes.binaries,
+        isReportExports: includedIssueTypes.exports ||
+            includedIssueTypes.types ||
+            includedIssueTypes.nsExports ||
+            includedIssueTypes.nsTypes ||
+            includedIssueTypes.enumMembers ||
+            includedIssueTypes.duplicates ||
+            isReportClassMembers,
+        isReportFiles: includedIssueTypes.files,
         isReportTypes: includedIssueTypes.types || includedIssueTypes.nsTypes || includedIssueTypes.enumMembers,
         isReportValues: includedIssueTypes.exports || includedIssueTypes.nsExports || isReportClassMembers,
         isSession: options.isSession ?? false,

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.76.1";
+export declare const version = "5.76.3";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.76.1';
+export const version = '5.76.3';

package/package.json

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