knip 5.44.5 → 5.45.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/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/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',
@@ -67,8 +68,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/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();
@@ -98,7 +101,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
             else if (isProductionEntry(input)) {
                 productionEntryFilePatterns.add(isAbsolute(s) ? relative(dir, s) : s);
             }
-            else if (!isConfigPattern(input)) {
+            else if (!isConfig(input)) {
                 const ws = (input.containingFilePath && chief.findWorkspaceByFilePath(input.containingFilePath)) || workspace;
                 const resolvedFilePath = getReferencedInternalFilePath(input, ws);
                 if (resolvedFilePath) {

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)[];

package/dist/plugins/eslint/helpers.js

@@ -1,13 +1,21 @@
 import { compact } from '../../util/array.js';
 import { toConfig, toDeferResolve } from '../../util/input.js';
 import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from '../../util/modules.js';
-import { isAbsolute, isInternal } from '../../util/path.js';
+import { extname, isAbsolute, isInternal } from '../../util/path.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
-export const getDependencies = (config, options) => {
+export const getInputs = (config, options) => {
+    const { configFileName } = options;
+    if (extname(configFileName) === '.json' || !/eslint\.config/.test(configFileName)) {
+        return getInputsDeprecated(config, options);
+    }
+    const dependencies = config.flatMap(config => config.settings ? getDependenciesFromSettings(config.settings).filter(id => id !== '@typescript-eslint/parser') : []);
+    return compact(dependencies).map(id => toDeferResolve(id));
+};
+const getInputsDeprecated = (config, options) => {
     const extendsSpecifiers = config.extends ? compact([config.extends].flat().map(resolveExtendSpecifier)) : [];
     if (extendsSpecifiers.some(specifier => specifier?.startsWith('eslint-plugin-prettier')))
         extendsSpecifiers.push('eslint-config-prettier');
-    const extendConfigs = extendsSpecifiers.map(specifier => toConfig('eslint', specifier, options.configFilePath));
+    const extendConfigs = extendsSpecifiers.map(specifier => toConfig('eslint', specifier, { containingFilePath: options.configFilePath }));
     const plugins = config.plugins ? config.plugins.map(resolvePluginSpecifier) : [];
     const parser = config.parser ?? config.parserOptions?.parser;
     const babelDependencies = config.parserOptions?.babelOptions
@@ -15,9 +23,9 @@ export const getDependencies = (config, options) => {
         : [];
     const settings = config.settings ? getDependenciesFromSettings(config.settings) : [];
     const rules = getDependenciesFromRules({});
-    const overrides = config.overrides ? [config.overrides].flat().flatMap(d => getDependencies(d, options)) : [];
-    const x = compact([...extendsSpecifiers, ...plugins, parser, ...settings, ...rules]).map(toDeferResolve);
-    return [...extendConfigs, ...x, ...babelDependencies, ...overrides];
+    const overrides = config.overrides ? [config.overrides].flat().flatMap(d => getInputsDeprecated(d, options)) : [];
+    const deferred = compact([...extendsSpecifiers, ...plugins, parser, ...settings, ...rules]).map(toDeferResolve);
+    return [...extendConfigs, ...deferred, ...babelDependencies, ...overrides];
 };
 const isQualifiedSpecifier = (specifier) => specifier === 'eslint' ||
     /\/eslint-(config|plugin)$/.test(specifier) ||

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

@@ -1,5 +1,8 @@
 import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
-import type { ESLintConfig } from './types.js';
+import type { ESLintConfigDeprecated } from './types.js';
+export declare const docs: {
+    note: string;
+};
 declare const _default: {
     title: string;
     enablers: string[];
@@ -7,6 +10,6 @@ declare const _default: {
     packageJsonPath: string;
     entry: string[];
     config: string[];
-    resolveConfig: ResolveConfig<ESLintConfig>;
+    resolveConfig: ResolveConfig<ESLintConfigDeprecated>;
 };
 export default _default;

package/dist/plugins/eslint/index.js

@@ -1,14 +1,42 @@
 import { hasDependency } from '../../util/plugin.js';
-import { getDependencies } from './helpers.js';
+import { getInputs } from './helpers.js';
 const title = 'ESLint';
 const enablers = ['eslint', '@eslint/js'];
 const isEnabled = ({ dependencies, manifest, config }) => hasDependency(dependencies, enablers) ||
     'eslint' in config ||
     Boolean(manifest.name && /(^eslint-config|\/eslint-config)/.test(manifest.name));
 const packageJsonPath = 'eslintConfig';
-const entry = ['eslint.config.{js,cjs,mjs}'];
+const entry = ['eslint.config.{js,cjs,mjs,ts,cts,mts}'];
 const config = ['.eslintrc', '.eslintrc.{js,json,cjs}', '.eslintrc.{yml,yaml}', 'package.json'];
-const resolveConfig = (localConfig, options) => getDependencies(localConfig, options);
+const resolveConfig = (localConfig, options) => getInputs(localConfig, options);
+const note = `### ESLint v9
+
+Only regular \`import\` statements are considered by default.
+The configuration object is not resolved to find dependencies for \`settings\` such as \`"eslint-import-resolver-typescript"\`.
+To enable this, lift the \`entry\` to a \`config\` file like so:
+
+\`\`\`json
+{
+  "eslint": ["eslint.config.ts"]
+}
+\`\`\`
+
+This is not enabled by default, since this exception may be thrown by a \`@rushstack/eslint-*\` package:
+
+> \`Error: Failed to patch ESLint because the calling module was not recognized.\`
+
+### ESLint v8
+
+If relying on [configuration cascading](https://eslint.org/docs/v8.x/use/configure/configuration-files#cascading-and-hierarchy),
+consider using an extended glob pattern like this:
+
+\`\`\`json
+{
+  "eslint": ["**/.eslintrc.js"]
+}
+\`\`\`
+`;
+export const docs = { note };
 export default {
     title,
     enablers,

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

@@ -17,12 +17,13 @@ type BaseConfig = {
     settings?: Settings;
     rules?: Rules;
 };
-export type OverrideConfig = BaseConfig & {
+export type ESLintConfig = BaseConfig[];
+export type OverrideConfigDeprecated = BaseConfig & {
     files: string[];
-    overrides: OverrideConfig;
+    overrides: OverrideConfigDeprecated;
 };
-export type ESLintConfig = BaseConfig & {
+export type ESLintConfigDeprecated = BaseConfig & {
     env?: Record<string, boolean>;
-    overrides?: OverrideConfig[];
+    overrides?: OverrideConfigDeprecated[];
 };
 export {};

package/dist/plugins/index.d.ts

@@ -133,7 +133,7 @@ export declare const Plugins: {
         packageJsonPath: string;
         entry: string[];
         config: string[];
-        resolveConfig: import("../types/config.js").ResolveConfig<import("./eslint/types.js").ESLintConfig>;
+        resolveConfig: import("../types/config.js").ResolveConfig<import("./eslint/types.js").ESLintConfigDeprecated>;
     };
     expo: {
         title: string;
@@ -403,12 +403,6 @@ export declare const Plugins: {
         entry: string[];
         resolveEntryPaths: import("../types/config.js").ResolveEntryPaths<import("./playwright/types.js").PlaywrightTestConfig>;
         resolveConfig: import("../types/config.js").ResolveConfig<import("./playwright/types.js").PlaywrightTestConfig>;
-        args: {
-            binaries: string[];
-            positional: boolean;
-            args: (args: string[]) => string[];
-            config: boolean;
-        };
     };
     'playwright-test': {
         title: string;

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

@@ -3,12 +3,6 @@ import type { PlaywrightTestConfig } from './types.js';
 export declare const entry: string[];
 export declare const resolveEntryPaths: ResolveEntryPaths<PlaywrightTestConfig>;
 export declare const resolveConfig: ResolveConfig<PlaywrightTestConfig>;
-export declare const args: {
-    binaries: string[];
-    positional: boolean;
-    args: (args: string[]) => string[];
-    config: boolean;
-};
 declare const _default: {
     title: string;
     enablers: string[];

package/dist/plugins/playwright/index.js

@@ -29,7 +29,7 @@ export const resolveConfig = async (config) => {
     });
     return [...reporters].map(toDeferResolve);
 };
-export const args = {
+const args = {
     binaries: ['playwright'],
     positional: true,
     args: (args) => args.filter(arg => arg !== 'install' && arg !== 'test'),

package/dist/plugins/playwright-ct/index.d.ts

@@ -7,11 +7,5 @@ declare const _default: {
     entry: string[];
     resolveEntryPaths: import("../../types/config.js").ResolveEntryPaths<import("../playwright/types.js").PlaywrightTestConfig>;
     resolveConfig: import("../../types/config.js").ResolveConfig<import("../playwright/types.js").PlaywrightTestConfig>;
-    args: {
-        binaries: string[];
-        positional: boolean;
-        args: (args: string[]) => string[];
-        config: boolean;
-    };
 };
 export default _default;

package/dist/plugins/playwright-ct/index.js

@@ -1,5 +1,5 @@
 import { hasDependency } from '../../util/plugin.js';
-import { args, entry, resolveConfig, resolveEntryPaths } from '../playwright/index.js';
+import { entry, resolveConfig, resolveEntryPaths } from '../playwright/index.js';
 const title = 'Playwright for components';
 const enablers = [/^@playwright\/experimental-ct-/];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -12,5 +12,4 @@ export default {
     entry,
     resolveEntryPaths,
     resolveConfig,
-    args,
 };

package/dist/plugins/typescript/index.js

@@ -9,11 +9,13 @@ const config = ['tsconfig.json'];
 const resolveConfig = async (localConfig, options) => {
     const { compilerOptions } = localConfig;
     const extend = localConfig.extends
-        ? [localConfig.extends].flat().map(specifier => toConfig('typescript', specifier, options.configFilePath))
+        ? [localConfig.extends]
+            .flat()
+            .map(specifier => toConfig('typescript', specifier, { containingFilePath: options.configFilePath }))
         : [];
     const references = localConfig.references
         ?.filter(reference => reference.path.endsWith('.json'))
-        .map(reference => toConfig('typescript', reference.path, options.configFilePath)) ?? [];
+        .map(reference => toConfig('typescript', reference.path, { containingFilePath: options.configFilePath })) ?? [];
     if (!(compilerOptions && localConfig))
         return compact([...extend, ...references]);
     const jsx = (compilerOptions?.jsxImportSource ? [compilerOptions.jsxImportSource] : []).map(toProductionDependency);

package/dist/plugins/xo/index.js

@@ -1,12 +1,12 @@
 import { hasDependency } from '../../util/plugin.js';
-import { getDependencies } from '../eslint/helpers.js';
+import { getInputs } from '../eslint/helpers.js';
 const title = 'xo';
 const enablers = ['xo'];
 const isEnabled = ({ dependencies, config }) => hasDependency(dependencies, enablers) || 'xo' in config;
 const config = ['package.json', '.xo-config', '.xo-config.{js,cjs,json}', 'xo.config.{js,cjs}'];
 const entry = ['.xo-config.{js,cjs}', 'xo.config.{js,cjs}'];
 const resolveConfig = async (config, options) => {
-    const inputs = getDependencies(config, options);
+    const inputs = getInputs(config, options);
     return [...inputs];
 };
 export default {

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

@@ -1,5 +1,5 @@
-import type { ESLintConfig } from '../eslint/types.js';
-export type XOConfig = ESLintConfig & {
+import type { ESLintConfigDeprecated } from '../eslint/types.js';
+export type XOConfig = ESLintConfigDeprecated & {
     envs?: string[] | undefined;
     globals?: string[] | undefined;
     ignores?: string[] | undefined;

package/dist/types/config.d.ts

@@ -14,7 +14,7 @@ export interface GetInputsFromScriptsOptions extends BaseOptions {
 }
 export type GetInputsFromScripts<T = GetInputsFromScriptsOptions> = (npmScripts: string | string[] | Set<string>, options: T) => Input[];
 export type GetInputsFromScriptsPartial = (npmScripts: string | string[] | Set<string>, options?: Partial<GetInputsFromScriptsOptions>) => Input[];
-type FromArgs = (args: string[]) => Input[];
+export type FromArgs = (args: string[], options?: Partial<GetInputsFromScriptsOptions>) => Input[];
 export interface BinaryResolverOptions extends GetInputsFromScriptsOptions {
     fromArgs: FromArgs;
 }

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

@@ -1,7 +1,7 @@
 import { IGNORED_RUNTIME_DEPENDENCIES } from '../constants.js';
 import { debugLog } from './debug.js';
 import { isDeferResolve, toDebugString } from './input.js';
-import { fromBinary, isBinary, isConfigPattern, isDeferResolveEntry, isDependency } from './input.js';
+import { fromBinary, isBinary, isConfig, isDeferResolveEntry, isDependency } from './input.js';
 import { getPackageNameFromSpecifier } from './modules.js';
 import { dirname, isAbsolute, isInternal, join } from './path.js';
 import { _resolveSync } from './resolve.js';
@@ -75,7 +75,7 @@ export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnore
         });
     }
     else if (!isGitIgnored(filePath)) {
-        if (!isDeferResolveEntry(input) && !isConfigPattern(input)) {
+        if (!isDeferResolveEntry(input) && !isConfig(input)) {
             collector.addIssue({
                 type: 'unresolved',
                 filePath: containingFilePath,

package/dist/util/input.d.ts

@@ -10,7 +10,7 @@ export interface Input {
 }
 export interface ConfigInput extends Input {
     type: 'config';
-    containingFilePath: string;
+    containingFilePath?: string;
     pluginName: PluginName;
 }
 type Options = {
@@ -25,8 +25,8 @@ export declare const toEntry: (specifier: string) => Input;
 export declare const isEntry: (input: Input) => boolean;
 export declare const toProductionEntry: (specifier: string, options?: Options) => Input;
 export declare const isProductionEntry: (input: Input) => boolean;
-export declare const toConfig: (pluginName: PluginName, specifier: string, containingFilePath: string) => ConfigInput;
-export declare const isConfigPattern: (input: Input) => input is ConfigInput;
+export declare const toConfig: (pluginName: PluginName, specifier: string, options?: Options) => ConfigInput;
+export declare const isConfig: (input: Input) => input is ConfigInput;
 export declare const toDependency: (specifier: string, options?: Options) => Input;
 export declare const isDependency: (input: Input) => boolean;
 export declare const toProductionDependency: (specifier: string) => Input;

package/dist/util/input.js

@@ -1,4 +1,4 @@
-import { toRelative } from './path.js';
+import { isAbsolute, toRelative } from './path.js';
 export const fromBinary = (input) => input.specifier;
 export const toBinary = (specifier, options = {}) => ({
     type: 'binary',
@@ -15,13 +15,13 @@ export const toProductionEntry = (specifier, options = {}) => ({
     ...options,
 });
 export const isProductionEntry = (input) => input.type === 'entry' && input.production === true;
-export const toConfig = (pluginName, specifier, containingFilePath) => ({
+export const toConfig = (pluginName, specifier, options = {}) => ({
     type: 'config',
     specifier,
     pluginName,
-    containingFilePath,
+    ...options,
 });
-export const isConfigPattern = (input) => input.type === 'config';
+export const isConfig = (input) => input.type === 'config';
 export const toDependency = (specifier, options = {}) => ({
     type: 'dependency',
     specifier,
@@ -44,4 +44,4 @@ export const toDeferResolveProductionEntry = (specifier) => ({
 export const isDeferResolveProductionEntry = (input) => input.type === 'deferResolveEntry' && input.production === true;
 export const toDeferResolveEntry = (specifier) => ({ type: 'deferResolveEntry', specifier });
 export const isDeferResolveEntry = (input) => input.type === 'deferResolveEntry';
-export const toDebugString = (input) => `${input.type}:${input.specifier}${input.containingFilePath ? ` (${toRelative(input.containingFilePath)})` : ''}`;
+export const toDebugString = (input) => `${input.type}:${isAbsolute(input.specifier) ? toRelative(input.specifier) : input.specifier}${input.containingFilePath ? ` (${toRelative(input.containingFilePath)})` : ''}`;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.44.5";
+export declare const version = "5.45.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.44.5';
+export const version = '5.45.0';

package/package.json

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