knip 5.44.5 → 5.46.0

package/README.md

@@ -9,9 +9,9 @@
 
 <div align="center">
 
-[![NPM Version](https://img.shields.io/npm/v/knip)][1]
-[![NPM Downloads](https://img.shields.io/npm/dm/knip)][1]
-[![GitHub Repo stars](https://img.shields.io/github/stars/webpro-nl/knip)][2]
+[![NPM Version](https://img.shields.io/npm/v/knip?color=f56e0f)][1]
+[![NPM Downloads](https://img.shields.io/npm/dm/knip?color=f56e0f)][1]
+[![GitHub Repo stars](https://img.shields.io/github/stars/webpro-nl/knip?style=flat-square&color=f56e0f)][2]
 
 </div>
 

package/dist/ConfigurationChief.d.ts

@@ -172,5 +172,6 @@ export declare class ConfigurationChief {
     getIncludedIssueTypes(cliArgs: CLIArguments): import("./types/issues.js").Report;
     findWorkspaceByFilePath(filePath: string): Workspace | undefined;
     getUnusedIgnoredWorkspaces(): string[];
+    getTags(): import("./types/cli.js").Tags;
 }
 export {};

package/dist/ConfigurationChief.js

@@ -18,6 +18,7 @@ import { getKeysByValue } from './util/object.js';
 import { join, relative } from './util/path.js';
 import { normalizePluginConfig } from './util/plugin.js';
 import { toRegexOrString } from './util/regex.js';
+import { splitTags } from './util/tag.js';
 import { unwrapFunction } from './util/unwrap-function.js';
 import { byPathDepth } from './util/workspace.js';
 const { config: rawConfigArg } = parsedArgValues;
@@ -43,6 +44,7 @@ const defaultConfig = {
     syncCompilers: new Map(),
     asyncCompilers: new Map(),
     rootPluginConfigs: {},
+    tags: [],
 };
 export class ConfigurationChief {
     cwd;
@@ -150,6 +152,7 @@ export class ConfigurationChief {
             syncCompilers: new Map(Object.entries(syncCompilers ?? {})),
             asyncCompilers: new Map(Object.entries(asyncCompilers ?? {})),
             rootPluginConfigs,
+            tags: rawConfig.tags ?? [],
         };
     }
     async setWorkspaces() {
@@ -371,4 +374,7 @@ export class ConfigurationChief {
             return !isDirectory(dir) || isFile(join(dir, 'package.json'));
         });
     }
+    getTags() {
+        return splitTags(this.config.tags);
+    }
 }

package/dist/IssueCollector.js

@@ -40,7 +40,8 @@ export class IssueCollector {
             if (this.isMatch(filePath))
                 continue;
             this.issues.files.add(filePath);
-            this.issues._files.add({ type: 'files', filePath, symbol: relative(filePath), severity: this.rules.files });
+            const symbol = relative(filePath);
+            this.issues._files[symbol] = [{ type: 'files', filePath, symbol, severity: this.rules.files }];
             this.counters.files++;
             this.counters.processed++;
         }

package/dist/IssueFixer.js

@@ -57,7 +57,7 @@ export class IssueFixer {
     async removeUnusedFiles(issues) {
         if (!this.isFixFiles)
             return;
-        for (const issue of issues._files) {
+        for (const issue of Object.values(issues._files).flatMap(Object.values)) {
             await rm(issue.filePath);
             issue.isFixed = true;
         }

package/dist/WorkspaceWorker.d.ts

@@ -1,4 +1,5 @@
 import { CacheConsultant } from './CacheConsultant.js';
+import type { Workspace } from './ConfigurationChief.js';
 import type { PluginName } from './types/PluginNames.js';
 import type { Configuration, WorkspaceConfiguration } from './types/config.js';
 import type { PackageJson } from './types/package-json.js';
@@ -12,6 +13,7 @@ type WorkspaceManagerOptions = {
     manifest: PackageJson;
     dependencies: DependencySet;
     getReferencedInternalFilePath: (input: Input) => string | undefined;
+    findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
     rootIgnore: Configuration['ignore'];
     negatedWorkspacePatterns: string[];
     ignoredWorkspacePatterns: string[];
@@ -21,6 +23,7 @@ type WorkspaceManagerOptions = {
     isCache: boolean;
     cacheLocation: string;
     allConfigFilePaths: Set<string>;
+    allConfigFilesMap: Map<string, Map<PluginName, Set<string>>>;
 };
 type CacheItem = {
     resolveEntryPaths?: Input[];
@@ -34,6 +37,7 @@ export declare class WorkspaceWorker {
     manifest: PackageJson;
     dependencies: DependencySet;
     getReferencedInternalFilePath: (input: Input) => string | undefined;
+    findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
     isProduction: boolean;
     isStrict: boolean;
     rootIgnore: Configuration['ignore'];
@@ -44,7 +48,8 @@ export declare class WorkspaceWorker {
     enabledPluginsInAncestors: string[];
     cache: CacheConsultant<CacheItem>;
     allConfigFilePaths: Set<string>;
-    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, isCache, cacheLocation, allConfigFilePaths, }: WorkspaceManagerOptions);
+    allConfigFilesMap: Map<string, Map<PluginName, Set<string>>>;
+    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, findWorkspaceByFilePath, isCache, cacheLocation, allConfigFilePaths, allConfigFilesMap, }: WorkspaceManagerOptions);
     init(): Promise<void>;
     private determineEnabledPlugins;
     private getConfigForPlugin;

package/dist/WorkspaceWorker.js

@@ -1,13 +1,14 @@
 import { CacheConsultant } from './CacheConsultant.js';
 import { _getInputsFromScripts } from './binaries/index.js';
+import { ROOT_WORKSPACE_NAME } from './constants.js';
 import { getFilteredScripts } from './manifest/helpers.js';
 import { PluginEntries, Plugins } from './plugins.js';
 import { compact } from './util/array.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate, prependDirToPattern } from './util/glob.js';
-import { isConfigPattern, toDebugString, toEntry } from './util/input.js';
+import { isConfig, toConfig, toDebugString, toEntry } from './util/input.js';
 import { getKeysByValue } from './util/object.js';
-import { basename, dirname, extname, join } from './util/path.js';
+import { basename, dirname, join } from './util/path.js';
 import { getFinalEntryPaths, loadConfigForPlugin } from './util/plugin.js';
 const nullConfig = { config: null, entry: null, project: null };
 const initEnabledPluginsMap = () => Object.keys(Plugins).reduce((enabled, pluginName) => ({ ...enabled, [pluginName]: false }), {});
@@ -19,6 +20,7 @@ export class WorkspaceWorker {
     manifest;
     dependencies;
     getReferencedInternalFilePath;
+    findWorkspaceByFilePath;
     isProduction;
     isStrict;
     rootIgnore;
@@ -29,7 +31,8 @@ export class WorkspaceWorker {
     enabledPluginsInAncestors;
     cache;
     allConfigFilePaths;
-    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, isCache, cacheLocation, allConfigFilePaths, }) {
+    allConfigFilesMap;
+    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, findWorkspaceByFilePath, isCache, cacheLocation, allConfigFilePaths, allConfigFilesMap, }) {
         this.name = name;
         this.dir = dir;
         this.cwd = cwd;
@@ -43,7 +46,9 @@ export class WorkspaceWorker {
         this.ignoredWorkspacePatterns = ignoredWorkspacePatterns;
         this.enabledPluginsInAncestors = enabledPluginsInAncestors;
         this.allConfigFilePaths = allConfigFilePaths;
+        this.allConfigFilesMap = allConfigFilesMap;
         this.getReferencedInternalFilePath = getReferencedInternalFilePath;
+        this.findWorkspaceByFilePath = findWorkspaceByFilePath;
         this.cache = new CacheConsultant({ name: `plugins-${name}`, isEnabled: isCache, cacheLocation });
     }
     async init() {
@@ -173,21 +178,25 @@ export class WorkspaceWorker {
         const hasProductionInput = (input) => productionInputsFromManifest.find(d => d.specifier === input.specifier && d.type === input.type);
         const createGetInputsFromScripts = (containingFilePath) => (scripts, options) => _getInputsFromScripts(scripts, { ...baseOptions, ...options, containingFilePath });
         const inputs = [];
-        const configFiles = new Map();
         const remainingPlugins = new Set(this.enabledPlugins);
         const addInput = (input, containingFilePath = input.containingFilePath) => inputs.push({ ...input, containingFilePath });
-        const handleConfigInput = (pluginName, dependency) => {
-            const configFilePath = this.getReferencedInternalFilePath(dependency);
+        const handleConfigInput = (pluginName, input) => {
+            const configFilePath = this.getReferencedInternalFilePath(input);
             if (configFilePath) {
-                if (!configFiles.has(pluginName))
-                    configFiles.set(pluginName, new Set());
-                configFiles.get(pluginName)?.add(configFilePath);
-                if (extname(dependency.specifier) !== '.json')
-                    addInput(toEntry(dependency.specifier), dependency.containingFilePath);
+                const workspace = this.findWorkspaceByFilePath(configFilePath);
+                if (workspace) {
+                    const name = this.name === ROOT_WORKSPACE_NAME ? workspace.name : this.name;
+                    const files = this.allConfigFilesMap;
+                    if (!files.has(name))
+                        files.set(name, new Map());
+                    if (!files.get(name)?.has(pluginName))
+                        files.get(name)?.set(pluginName, new Set());
+                    files.get(name)?.get(pluginName)?.add(configFilePath);
+                }
             }
         };
         for (const input of [...inputsFromManifest, ...productionInputsFromManifest]) {
-            if (isConfigPattern(input)) {
+            if (isConfig(input)) {
                 handleConfigInput(input.pluginName, { ...input, containingFilePath });
             }
             else {
@@ -208,9 +217,13 @@ export class WorkspaceWorker {
             const label = 'config file';
             const configFilePaths = await _glob({ patterns, cwd: rootCwd, dir: cwd, gitignore: false, label });
             const remainingConfigFilePaths = configFilePaths.filter(filePath => !this.allConfigFilePaths.has(filePath));
-            for (const f of remainingConfigFilePaths)
-                if (basename(f) !== 'package.json')
-                    this.allConfigFilePaths.add(f);
+            for (const filePath of remainingConfigFilePaths) {
+                if (basename(filePath) !== 'package.json') {
+                    this.allConfigFilePaths.add(filePath);
+                    addInput(toEntry(filePath));
+                    addInput(toConfig(pluginName, filePath));
+                }
+            }
             const options = {
                 ...baseScriptOptions,
                 config,
@@ -252,10 +265,12 @@ export class WorkspaceWorker {
                             if (hasResolveConfig) {
                                 const inputs = (await plugin.resolveConfig?.(config, opts)) ?? [];
                                 for (const input of inputs) {
-                                    if (isConfigPattern(input)) {
+                                    if (isConfig(input)) {
                                         handleConfigInput(input.pluginName, { ...input, containingFilePath: configFilePath });
                                     }
-                                    addInput(input, configFilePath);
+                                    else {
+                                        addInput(input, configFilePath);
+                                    }
                                 }
                                 data.resolveConfig = inputs;
                             }
@@ -276,22 +291,28 @@ export class WorkspaceWorker {
         };
         const enabledPluginTitles = this.enabledPlugins.map(name => Plugins[name].title);
         debugLogObject(this.name, 'Enabled plugins', enabledPluginTitles);
+        const configFiles = this.allConfigFilesMap.get(name);
         for (const pluginName of this.enabledPlugins) {
-            const patterns = [...this.getConfigurationFilePatterns(pluginName), ...(configFiles.get(pluginName) ?? [])];
-            configFiles.delete(pluginName);
+            const patterns = [...this.getConfigurationFilePatterns(pluginName), ...(configFiles?.get(pluginName) ?? [])];
+            configFiles?.delete(pluginName);
             await runPlugin(pluginName, compact(patterns));
             remainingPlugins.delete(pluginName);
         }
-        do {
-            for (const [pluginName, dependencies] of configFiles.entries()) {
-                configFiles.delete(pluginName);
-                if (this.enabledPlugins.includes(pluginName))
-                    await runPlugin(pluginName, Array.from(dependencies));
-                else
-                    for (const id of dependencies)
-                        addInput(toEntry(id));
+        {
+            const configFiles = this.allConfigFilesMap.get(name);
+            if (configFiles) {
+                do {
+                    for (const [pluginName, dependencies] of configFiles.entries()) {
+                        configFiles.delete(pluginName);
+                        if (this.enabledPlugins.includes(pluginName))
+                            await runPlugin(pluginName, Array.from(dependencies));
+                        else
+                            for (const id of dependencies)
+                                addInput(toEntry(id));
+                    }
+                } while (remainingPlugins.size > 0 && configFiles.size > 0);
             }
-        } while (remainingPlugins.size > 0 && configFiles.size > 0);
+        }
         debugLogArray(name, 'Plugin dependencies', () => compact(inputs.map(toDebugString)));
         return inputs;
     }

package/dist/binaries/bash-parser.js

@@ -15,9 +15,10 @@ const isAssignment = (node) => 'type' in node && node.type === 'AssignmentWord';
 export const getDependenciesFromScript = (script, options) => {
     if (!script)
         return [];
-    const fromArgs = (args) => {
+    const fromArgs = (args, opts) => {
         return getDependenciesFromScript(args.filter(arg => arg !== '--').join(' '), {
             ...options,
+            ...opts,
             knownBinsOnly: false,
         });
     };

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

@@ -5,7 +5,7 @@ import { isAbsolute, join } from '../../util/path.js';
 import { resolveX } from './bunx.js';
 const commands = ['add', 'create', 'init', 'install', 'link', 'pm', 'remove', 'run', 'test', 'update', 'upgrade', 'x'];
 export const resolve = (_binary, args, options) => {
-    const parsed = parseArgs(args);
+    const parsed = parseArgs(args, { string: ['cwd'] });
     const [command, script] = parsed._;
     if (command === 'x') {
         const argsForX = args.filter(arg => arg !== 'x');
@@ -14,11 +14,15 @@ export const resolve = (_binary, args, options) => {
     const { manifestScriptNames, cwd, fromArgs } = options;
     if (command === 'run' && manifestScriptNames.has(script))
         return [];
-    if (manifestScriptNames.has(command) || commands.includes(command))
+    if (manifestScriptNames.has(command))
+        return [];
+    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)];
-    return fromArgs(args);
+    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/yarn.js

@@ -2,6 +2,7 @@ import parseArgs from 'minimist';
 import { isBinary, isDependency, toBinary, toDependency } from '../../util/input.js';
 import { stripVersionFromSpecifier } from '../../util/modules.js';
 import { join } from '../../util/path.js';
+import { argsFrom } from '../util.js';
 const commands = [
     'add',
     'bin',
@@ -51,6 +52,8 @@ export const resolve = (_binary, args, options) => {
     const parsed = parseArgs(args, { boolean: ['top-level'], string: ['cwd'] });
     const dir = parsed['top-level'] ? rootCwd : parsed.cwd ? join(cwd, parsed.cwd) : undefined;
     const [command, binary] = parsed._;
+    if (!command && !binary)
+        return [];
     if (command === 'run') {
         if (manifestScriptNames.has(binary))
             return [];
@@ -67,8 +70,6 @@ export const resolve = (_binary, args, options) => {
     }
     if ((!dir && manifestScriptNames.has(command)) || commands.includes(command))
         return [];
-    const bin = command === 'exec' ? toBinary(binary) : toBinary(command);
-    if (dir)
-        Object.assign(bin, { dir });
-    return [bin];
+    const opts = dir ? { cwd: dir } : {};
+    return fromArgs(argsFrom(args, command === 'exec' ? binary : command), opts);
 };

package/dist/binaries/plugins.js

@@ -3,6 +3,7 @@ import { pluginArgsMap } from '../plugins.js';
 import { compact } from '../util/array.js';
 import { toBinary, toConfig, toDeferResolve, toDeferResolveEntry, toEntry } from '../util/input.js';
 import { extractBinary } from '../util/modules.js';
+import { dirname } from '../util/path.js';
 import { resolve as fallbackResolve } from './fallback.js';
 const isGlobLikeMatch = /(^!|[*+\\(|{^$])/;
 const isGlobLike = (value) => isGlobLikeMatch.test(value);
@@ -12,23 +13,25 @@ export const resolve = (binary, _args, options) => {
     const [pluginName, pluginArgs] = pluginArgsMap.get(binary) ?? [];
     if (!pluginArgs)
         return fallbackResolve(binary, _args, options);
-    const opts = pluginArgs;
-    const args = typeof opts.args === 'function' ? opts.args(_args) : _args;
+    const inputOpts = {};
+    if (options.cwd && dirname(containingFilePath) !== options.cwd)
+        Object.assign(inputOpts, { dir: options.cwd });
+    const args = typeof pluginArgs.args === 'function' ? pluginArgs.args(_args) : _args;
     const parsed = parseArgs(args, {
         string: [
-            ...(opts.nodeImportArgs ? ['import'] : []),
-            ...(opts.config === true ? ['config'] : []),
-            ...(opts.string ?? []),
+            ...(pluginArgs.nodeImportArgs ? ['import'] : []),
+            ...(pluginArgs.config === true ? ['config'] : []),
+            ...(pluginArgs.string ?? []),
         ],
-        boolean: ['quiet', 'verbose', 'watch', ...(opts.boolean ?? [])],
+        boolean: ['quiet', 'verbose', 'watch', ...(pluginArgs.boolean ?? [])],
         alias: {
-            ...(opts.nodeImportArgs ? nodeLoadersArgs : {}),
-            ...(opts.config === true ? { config: ['c'] } : {}),
-            ...opts.alias,
+            ...(pluginArgs.nodeImportArgs ? nodeLoadersArgs : {}),
+            ...(pluginArgs.config === true ? { config: ['c'] } : {}),
+            ...pluginArgs.alias,
         },
     });
     const positionals = [];
-    if (opts.positional && parsed._[0]) {
+    if (pluginArgs.positional && parsed._[0]) {
         const id = parsed._[0];
         if (isGlobLike(id))
             positionals.push(toEntry(id));
@@ -40,23 +43,23 @@ export const resolve = (binary, _args, options) => {
         }
     }
     const mapToParsedKey = (id) => parsed[id];
-    const resolved = compact(opts.resolve ? opts.resolve.flatMap(mapToParsedKey) : []);
-    const resolvedImports = opts.nodeImportArgs && parsed.import ? [parsed.import].flat() : [];
-    const resolvedFromArgs = typeof opts.fromArgs === 'function'
-        ? fromArgs(opts.fromArgs(parsed, args))
-        : Array.isArray(opts.fromArgs)
-            ? fromArgs(opts.fromArgs.flatMap(mapToParsedKey))
+    const resolved = compact(pluginArgs.resolve ? pluginArgs.resolve.flatMap(mapToParsedKey) : []);
+    const resolvedImports = pluginArgs.nodeImportArgs && parsed.import ? [parsed.import].flat() : [];
+    const resolvedFromArgs = typeof pluginArgs.fromArgs === 'function'
+        ? fromArgs(pluginArgs.fromArgs(parsed, args))
+        : Array.isArray(pluginArgs.fromArgs)
+            ? fromArgs(pluginArgs.fromArgs.flatMap(mapToParsedKey))
             : [];
-    const config = opts.config === true ? ['config'] : opts.config || [];
+    const config = pluginArgs.config === true ? ['config'] : pluginArgs.config || [];
     const mapToConfigPattern = (value) => {
         if (typeof value === 'string')
-            return parsed[value] && pluginName ? [toConfig(pluginName, parsed[value], containingFilePath)] : [];
+            return parsed[value] && pluginName ? [toConfig(pluginName, parsed[value], inputOpts)] : [];
         const [id, fn] = value;
-        return parsed[id] && pluginName ? [toConfig(pluginName, fn(parsed[id]), containingFilePath)] : [];
+        return parsed[id] && pluginName ? [toConfig(pluginName, fn(parsed[id]), inputOpts)] : [];
     };
     const configFilePaths = config.flatMap(mapToConfigPattern);
     return [
-        toBinary(binary),
+        toBinary(binary, inputOpts),
         ...positionals,
         ...resolved.map(toDeferResolve),
         ...resolvedImports.map(toDeferResolve),

package/dist/cli.js

@@ -10,7 +10,7 @@ import { splitTags } from './util/tag.js';
 import { isTrace } from './util/trace.js';
 import { version } from './version.js';
 const defaultCacheLocation = join(cwd, 'node_modules', '.cache', 'knip');
-const { 'allow-remove-files': isRemoveFiles = false, cache: isCache = false, 'cache-location': cacheLocation = defaultCacheLocation, debug: isDebug = false, dependencies: isDependenciesShorthand = false, exclude: excludedIssueTypes = [], 'experimental-tags': experimentalTags = [], exports: isExportsShorthand = false, files: isFilesShorthand = false, fix: isFix = false, 'fix-type': fixTypes = [], help: isHelp, include: includedIssueTypes = [], 'include-entry-exports': isIncludeEntryExports = false, 'include-libs': isIncludeLibs = false, 'isolate-workspaces': isIsolateWorkspaces = false, 'max-issues': maxIssues = '0', 'no-config-hints': isHideConfigHints = false, 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = isDebug || isTrace, preprocessor = [], 'preprocessor-options': preprocessorOptions = '', production: isProduction = false, reporter = ['symbols'], 'reporter-options': reporterOptions = '', strict: isStrict = false, tags = [], tsConfig, version: isVersion, watch: isWatch = false, workspace: rawWorkspaceArg, } = parsedArgValues;
+const { 'allow-remove-files': isRemoveFiles = false, cache: isCache = false, 'cache-location': cacheLocation = defaultCacheLocation, debug: isDebug = false, dependencies: isDependenciesShorthand = false, exclude: excludedIssueTypes = [], 'experimental-tags': experimentalTags = [], exports: isExportsShorthand = false, files: isFilesShorthand = false, fix: isFix = false, 'fix-type': fixTypes = [], help: isHelp, include: includedIssueTypes = [], 'include-entry-exports': isIncludeEntryExports = false, 'include-libs': isIncludeLibs = false, 'isolate-workspaces': isIsolateWorkspaces = false, 'max-issues': maxIssues = '0', 'no-config-hints': isDisableConfigHints = false, 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = isDebug || isTrace, preprocessor = [], 'preprocessor-options': preprocessorOptions = '', production: isProduction = false, reporter = ['symbols'], 'reporter-options': reporterOptions = '', strict: isStrict = false, tags = [], 'treat-config-hints-as-errors': isTreatConfigHintsAsErrors = false, tsConfig, version: isVersion, watch: isWatch = false, workspace: rawWorkspaceArg, } = parsedArgValues;
 if (isHelp) {
     console.log(helpText);
     process.exit(0);
@@ -36,7 +36,7 @@ const run = async () => {
             isExportsShorthand,
             isFilesShorthand,
             isFix: isFix || fixTypes.length > 0,
-            isHideConfigHints,
+            isDisableConfigHints,
             isIncludeEntryExports,
             isIncludeLibs,
             isIsolateWorkspaces,
@@ -57,7 +57,8 @@ const run = async () => {
             counters,
             tagHints,
             configurationHints,
-            noConfigHints: isHideConfigHints,
+            isDisableConfigHints,
+            isTreatConfigHintsAsErrors,
             cwd,
             isProduction,
             isShowProgress,
@@ -83,7 +84,8 @@ const run = async () => {
         if (isIsolateWorkspaces && report.classMembers) {
             logWarning('WARNING', 'Class members are not tracked when using the --isolate-workspaces flag');
         }
-        if (!noExitCode && totalErrorCount > Number(maxIssues)) {
+        if ((!noExitCode && totalErrorCount > Number(maxIssues)) ||
+            (isTreatConfigHintsAsErrors && configurationHints.size > 0)) {
             process.exit(1);
         }
     }

package/dist/compilers/index.d.ts

@@ -5,6 +5,7 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     syncCompilers: Record<string, SyncCompilerFn>;
     asyncCompilers: Record<string, AsyncCompilerFn>;
     exclude?: ("dependencies" | "exports" | "files" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers")[] | undefined;
+    tags?: string[] | undefined;
     include?: ("dependencies" | "exports" | "files" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers")[] | undefined;
     node?: string | boolean | string[] | {
         config?: string | string[] | undefined;

package/dist/graph/analyze.d.ts

@@ -17,7 +17,7 @@ interface AnalyzeOptions {
     fixer: IssueFixer;
     graph: ModuleGraph;
     isFix: boolean;
-    isHideConfigHints: boolean;
+    isDisableConfigHints: boolean;
     isIncludeLibs: boolean;
     isProduction: boolean;
     report: Report;

package/dist/graph/analyze.js

@@ -5,13 +5,13 @@ import { findMatch } from '../util/regex.js';
 import { getShouldIgnoreHandler, getShouldIgnoreTagHandler } from '../util/tag.js';
 import { createAndPrintTrace, printTrace } from '../util/trace.js';
 export const analyze = async (options) => {
-    const { analyzedFiles, chief, collector, deputy, entryPaths, factory, fixer, graph, isFix, isHideConfigHints, isIncludeLibs, isProduction, report, streamer, tags, unreferencedFiles, workspace, } = options;
+    const { analyzedFiles, chief, collector, deputy, entryPaths, factory, fixer, graph, isFix, isDisableConfigHints, isIncludeLibs, isProduction, report, streamer, tags, unreferencedFiles, workspace, } = options;
     const isReportDependencies = report.dependencies || report.unlisted || report.unresolved;
     const isReportValues = report.exports || report.nsExports || report.classMembers;
     const isReportTypes = report.types || report.nsTypes || report.enumMembers;
     const isReportClassMembers = report.classMembers;
     const isSkipLibs = !(isIncludeLibs || isReportClassMembers);
-    const isShowConfigHints = !workspace && !isProduction && !isHideConfigHints;
+    const isShowConfigHints = !workspace && !isProduction && !isDisableConfigHints;
     const shouldIgnore = getShouldIgnoreHandler(isProduction);
     const shouldIgnoreTags = getShouldIgnoreTagHandler(tags);
     const isIdentifierReferenced = getIsIdentifierReferencedHandler(graph, entryPaths);

package/dist/graph/build.js

@@ -4,7 +4,7 @@ import { getCompilerExtensions, getIncludedCompilers } from '../compilers/index.
 import { debugLog, debugLogArray } from '../util/debug.js';
 import { getReferencedInputsHandler } from '../util/get-referenced-inputs.js';
 import { _glob, negate } from '../util/glob.js';
-import { isConfigPattern, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isProductionEntry, toProductionEntry, } from '../util/input.js';
+import { isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isProductionEntry, toProductionEntry, } from '../util/input.js';
 import { getOrCreateFileNode, updateImportMap } from '../util/module-graph.js';
 import { getEntryPathsFromManifest } from '../util/package-json.js';
 import { dirname, isAbsolute, join, relative } from '../util/path.js';
@@ -13,6 +13,7 @@ import { augmentWorkspace, getToSourcePathHandler } from '../util/to-source-path
 import { loadTSConfig } from '../util/tsconfig-loader.js';
 export async function build({ cacheLocation, chief, collector, cwd, deputy, factory, gitignore, isCache, isFixExports, isFixTypes, isGitIgnored, isIsolateWorkspaces, isProduction, isSkipLibs, isStrict, isWatch, report, streamer, tags, tsConfigFile, workspaces, }) {
     const allConfigFilePaths = new Set();
+    const allConfigFilesMap = new Map();
     const enabledPluginsStore = new Map();
     const toSourceFilePath = getToSourcePathHandler(chief);
     const getReferencedInternalFilePath = getReferencedInputsHandler(collector, deputy, chief, isGitIgnored);
@@ -47,6 +48,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
             manifest,
             dependencies,
             getReferencedInternalFilePath: (input) => getReferencedInternalFilePath(input, workspace),
+            findWorkspaceByFilePath: chief.findWorkspaceByFilePath.bind(chief),
             isProduction,
             isStrict,
             rootIgnore: chief.config.ignore,
@@ -56,6 +58,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
             isCache,
             cacheLocation,
             allConfigFilePaths,
+            allConfigFilesMap,
         });
         await worker.init();
         const inputs = new Set();
@@ -91,14 +94,14 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
         const entryFilePatterns = new Set();
         const productionEntryFilePatterns = new Set();
         for (const input of inputs) {
-            const s = input.specifier;
+            const specifier = input.specifier;
             if (isEntry(input)) {
-                entryFilePatterns.add(isAbsolute(s) ? relative(dir, s) : s);
+                entryFilePatterns.add(isAbsolute(specifier) ? relative(dir, specifier) : specifier);
             }
             else if (isProductionEntry(input)) {
-                productionEntryFilePatterns.add(isAbsolute(s) ? relative(dir, s) : s);
+                productionEntryFilePatterns.add(isAbsolute(specifier) ? relative(dir, specifier) : specifier);
             }
-            else if (!isConfigPattern(input)) {
+            else if (!isConfig(input)) {
                 const ws = (input.containingFilePath && chief.findWorkspaceByFilePath(input.containingFilePath)) || workspace;
                 const resolvedFilePath = getReferencedInternalFilePath(input, ws);
                 if (resolvedFilePath) {
@@ -214,13 +217,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
                 const dependencies = deputy.getDependencies(workspace.name);
                 const manifestScriptNames = new Set(Object.keys(chief.getManifestForWorkspace(workspace.name)?.scripts ?? {}));
                 const dir = dirname(filePath);
-                const options = {
-                    cwd: dir,
-                    rootCwd: cwd,
-                    containingFilePath: filePath,
-                    dependencies,
-                    manifestScriptNames,
-                };
+                const options = { cwd: dir, rootCwd: cwd, containingFilePath: filePath, dependencies, manifestScriptNames };
                 const inputs = _getInputsFromScripts(scripts, options);
                 for (const input of inputs) {
                     input.containingFilePath ??= filePath;

package/dist/index.js

@@ -11,7 +11,7 @@ import { debugLogObject } from './util/debug.js';
 import { getGitIgnoredHandler } from './util/glob-core.js';
 import { getWatchHandler } from './util/watch.js';
 export const main = async (unresolvedConfiguration) => {
-    const { cacheLocation, cwd, excludedIssueTypes, fixTypes, gitignore, includedIssueTypes, isCache, isDebug, isDependenciesShorthand, isExportsShorthand, isFilesShorthand, isFix, isHideConfigHints, isIncludeEntryExports, isIncludeLibs, isIsolateWorkspaces, isProduction, isRemoveFiles, isShowProgress, isStrict, isWatch, tags, tsConfigFile, workspace, } = unresolvedConfiguration;
+    const { cacheLocation, cwd, excludedIssueTypes, fixTypes, gitignore, includedIssueTypes, isCache, isDebug, isDependenciesShorthand, isExportsShorthand, isFilesShorthand, isFix, isDisableConfigHints, isIncludeEntryExports, isIncludeLibs, isIsolateWorkspaces, isProduction, isRemoveFiles, isShowProgress, isStrict, isWatch, tags, tsConfigFile, workspace, } = unresolvedConfiguration;
     debugLogObject('*', 'Unresolved configuration (from CLI arguments)', unresolvedConfiguration);
     const chief = new ConfigurationChief({ cwd, isProduction, isStrict, isIncludeEntryExports, workspace });
     const deputy = new DependencyDeputy({ isProduction, isStrict });
@@ -29,6 +29,7 @@ export const main = async (unresolvedConfiguration) => {
     });
     const rules = chief.getRules();
     const filters = chief.getFilters();
+    const finalTags = tags[0].length > 0 || tags[1].length > 0 ? tags : chief.getTags();
     const fixer = new IssueFixer({ isEnabled: isFix, cwd, fixTypes, isRemoveFiles });
     debugLogObject('*', 'Included issue types', report);
     const isReportClassMembers = report.classMembers;
@@ -57,7 +58,7 @@ export const main = async (unresolvedConfiguration) => {
         isWatch,
         report,
         streamer,
-        tags,
+        tags: finalTags,
         tsConfigFile,
         workspaces,
     });
@@ -71,12 +72,12 @@ export const main = async (unresolvedConfiguration) => {
         fixer,
         graph,
         isFix,
-        isHideConfigHints,
+        isDisableConfigHints,
         isIncludeLibs,
         isProduction,
         report,
         streamer,
-        tags,
+        tags: finalTags,
         unreferencedFiles,
         workspace,
     });

package/dist/plugins/angular/index.js

@@ -22,7 +22,7 @@ const resolveConfig = async (config, options) => {
                 inputs.add(toDependency(packageName));
             if (opts) {
                 if ('tsConfig' in opts && typeof opts.tsConfig === 'string') {
-                    inputs.add(toConfig('typescript', opts.tsConfig, configFilePath));
+                    inputs.add(toConfig('typescript', opts.tsConfig, { containingFilePath: configFilePath }));
                 }
             }
             const defaultEntriesByOption = opts ? entriesByOption(opts) : new Map();
@@ -73,7 +73,7 @@ const resolveConfig = async (config, options) => {
                     karma.inputsFromFrameworks(['jasmine']).forEach(inputs.add, inputs);
                 }
                 if (karmaConfig && !karma.configFiles.includes(karmaConfig)) {
-                    inputs.add(toConfig('karma', karmaConfig, options.configFilePath));
+                    inputs.add(toConfig('karma', karmaConfig, { containingFilePath: options.configFilePath }));
                 }
             }
         }

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

@@ -1,4 +1,4 @@
 import type { PluginOptions } from '../../types/config.js';
 import { type ConfigInput, type Input } from '../../util/input.js';
-import type { ESLintConfig, OverrideConfig } from './types.js';
-export declare const getDependencies: (config: ESLintConfig | OverrideConfig, options: PluginOptions) => (Input | ConfigInput)[];
+import type { ESLintConfig, ESLintConfigDeprecated, OverrideConfigDeprecated } from './types.js';
+export declare const getInputs: (config: ESLintConfigDeprecated | OverrideConfigDeprecated | ESLintConfig, options: PluginOptions) => (Input | ConfigInput)[];