knip 1.0.0-alpha.2 → 1.0.0-alpha.3

package/README.md

@@ -21,22 +21,23 @@ The dots don't connect themselves. This is where Knip comes in:
 - [x] Finds duplicate exports.
 - [x] Finds unused members of classes and enums
 - [x] Built-in support for monorepos (workspaces)
-- [x] Growing list of built-in plugins (= less to configure and custom dependency resolvers)
+- [x] Growing list of [built-in plugins][1]
+- [x] Checks npm scripts for used and unlisted dependencies
 - [x] Supports JavaScript (without `tsconfig.json`, or TypeScript `allowJs: true`).
-- [x] Features multiple [reporters][1] and supports [custom reporters][2] (think JSON and `CODEOWNERS`)
+- [x] Features multiple [reporters][2] and supports [custom reporters][3]
 - [x] Run Knip as part of your CI environment to detect issues and prevent regressions.
 
 Knip really shines in larger projects. A little bit of configuration will pay off, I promise. A comparison with similar
-tools answers the question [why another unused file/dependency/export finder?][3]
+tools answers the question [why another unused file/dependency/export finder?][4]
 
 Knip is a fresh take on keeping your projects clean & tidy!
 
-[![An orange cow with scissors, Van Gogh style][5]][4] <sup>_“An orange cow with scissors, Van Gogh style” - generated
+[![An orange cow with scissors, Van Gogh style][6]][5] <sup>_“An orange cow with scissors, Van Gogh style” - generated
 with OpenAI_</sup>
 
 ## Roadmap
 
-Please report any false positives by [opening an issue in this repo][6]. Bonus points for adding a public repository or
+Please report any false positives by [opening an issue in this repo][7]. Bonus points for adding a public repository or
 opening a pull request with a directory and example files in `test/fixtures`. Correctness and bug fixes have priority
 over new features:
 
@@ -92,15 +93,17 @@ Knip works by creating two sets of files:
       -c/--config [file]     Configuration file path (default: ./knip.json, knip.jsonc or package.json#knip)
       -t/--tsConfig [file]   TypeScript configuration path (default: ./tsconfig.json)
       --production           Analyze only production source files (e.g. no tests, devDependencies, exported types)
+      --strict               Consider only direct dependencies of workspaces. Not devDependencies, not ancestor workspaces.
       --workspace            Analyze a single workspace (default: analyze all configured workspaces)
       --include              Report only listed issue type(s), can be repeated
       --exclude              Exclude issue type(s) from report, can be repeated
       --no-progress          Don't show dynamic progress updates
+      --no-exit-code         Always exit with code zero (0)
       --max-issues           Maximum number of issues before non-zero exit code (default: 0)
       --reporter             Select reporter: symbols, compact, codeowners, json (default: symbols)
       --reporter-options     Pass extra options to the reporter (as JSON string, see example)
       --debug                Show debug output
-      --debug-level          Set verbosity of debug output (default: 1, max: 2)
+      --debug-level          Set verbosity of debug output (default: 1, max: 3)
       --performance          Measure running time of expensive functions and display stats table
 
     Issue types: files, dependencies, unlisted, exports, nsExports, classMembers, types, nsTypes, enumMembers, duplicates
@@ -212,31 +215,46 @@ analyze unused dependencies and exports from any directory with a `package.json`
 
 Knip contains a growing list of plugins:
 
-- Babel
-- Capacitor
-- Changesets
-- Cypress
-- ESLint
-- Gatsby
-- Jest
-- Next.js
-- Nx
-- Playwright
-- PostCSS
-- Remark
-- Remix
-- Rollup
-- Storybook
+- [Babel][9]
+- [Capacitor][10]
+- [Changesets][11]
+- [Cypress][12]
+- [ESLint][13]
+- [Gatsby][14]
+- [Jest][15]
+- [Mocha][16]
+- [Next.js][17]
+- [Nx][18]
+- [Playwright][19]
+- [PostCSS][20]
+- [Remark][21]
+- [Remix][22]
+- [Rollup][23]
+- [Storybook][24]
+- [Stryker][25]
 
 Plugins are automatically activated, no need to enable anything. Each plugin is automatically enabled based on simple
 heuristics. Most of them check whether one or one of a few (dev) dependencies are listed in `package.json`. Once
-enabled, they add the right set of configuration and entry files for Knip to analyze.
+enabled, they add a set of configuration and/or entry files for Knip to analyze. These defaults can be overriden.
 
-Most configuration files are easy to find dependencies in. Yet some of the plugins include custom dependency resolvers.
-For instance, the `eslint` plugin tells Knip that an `"import"` entry in the array of plugins means that the
-`eslint-plugin-import` dependency should be installed. Or the `storybook` plugin understands that
-`core.builder: 'webpack5'` in `main.js` means that the `@storybook/builder-webpack5` and `@storybook/manager-webpack5`
-dependencies are required.
+Most plugins use one or both of the following file types:
+
+- `config` - custom dependency resolvers are applied to these files
+- `entryFiles` - files to include with the analysis of the rest of the source code
+
+Many configuration files use `require` or `import` statements to use dependencies, so they can be analyzed like the rest
+of the source files. These configuration files are also `entryFiles`.
+
+Many plugins also include `config` files. They are parsed by custom dependency resolvers.
+
+- The `eslint` plugin tells Knip that an `"prettier"` entry in the array of plugins means that the
+  `eslint-plugin-prettier` dependency should be installed.
+- The `storybook` plugin understands that `core.builder: 'webpack5'` in `main.js` means that the
+  `@storybook/builder-webpack5` and `@storybook/manager-webpack5` dependencies are required.
+- Static configuration files such as JSON and YAML always require a custom dependency resolver.
+
+The only thing that a custom dependency resolver function does is return all referenced dependencies for the
+configuration files it is given.
 
 ## Configuration
 
@@ -258,26 +276,34 @@ export const merge = function () {};
 
 Knip does not report public exports and types as unused.
 
-### Production mode
-
-The default configuration for Knip is loose and targets all project code. Non-production files such as tests often
-import production files, which will prevent the production files from being reported as unused.
+### Production Mode
 
-Non-production code includes files such as unit tests, end-to-end tests, tooling, scripts, Storybook stories, etc. Think
-of it the same way as the convention to split `dependencies` and `devDependencies` in `package.json`.
+The default mode for Knip is holistic and targets all project code. For instance test files usually import production
+files. This prevents the production files or its exports from being reported as unused, while both of them can be
+removed. This is why Knip has a production mode.
 
-To exclude non-production code such as configuration files and tests, use production mode with `--production`. This will
-only include the files meant for production use. Add an exclamation mark behind the patterns that are meant for
-production like so:
+To analyze only production code, add an exclamation mark behind the patterns that are meant for production and use the
+`--production` flag to analyze (only) them. Here's an example:
 
 ```json
 {
   "entryFiles": ["build/script.js", "src/index.ts!"],
-  "projectFiles": ["src/**/*.ts"]
+  "projectFiles": ["src/**/*.ts!"]
 }
 ```
 
-Configuration, build and test files are not included. Knip finds unused files and export values in production code only.
+Configuration files, test files and build scripts should not be included. Knip looks for unused files, dependencies and
+export values in production code only.
+
+#### Strict
+
+Additionally, the `--strict` flag can be used to:
+
+- Consider only `dependencies` (not `devDependencies`) when finding unused or unlisted dependencies.
+- Assume each workspace is self-contained: they have their own `dependencies` (and not rely on packages of ancestor
+  workspaces).
+
+#### Plugins
 
 Plugins also have this distinction. For instance, Next.js entry files for pages (`pages/**/*.tsx`) and Remix routes
 (`app/routes/**/*.tsx`) are production code, while Jest and Playwright entry files (e.g. `*.spec.ts`) are not. All of
@@ -288,10 +314,10 @@ locations. The more plugins Knip will have, the more projects can be analyzed ou
 
 Knip provides the following built-in reporters:
 
-- [`json`][9]
-- [`symbol`][10] (default)
-- [`compact`][11]
-- [`codeowners`][12]
+- [`json`][26]
+- [`symbol`][27] (default)
+- [`compact`][28]
+- [`codeowners`][29]
 
 ### Custom Reporters
 
@@ -346,11 +372,11 @@ per file like this:
 ]
 ```
 
-The keys match the [known issue types][13].
+The keys match the [known issue types][30].
 
 #### Usage Ideas
 
-Use tools like [miller][14] or [jtbl][15] to consume the JSON and render a table in the terminal.
+Use tools like [miller][31] or [jtbl][32] to consume the JSON and render a table in the terminal.
 
 ##### Table
 
@@ -467,12 +493,12 @@ collect the various issues in one go?
 
 This table is a work in progress, but here's a first impression. Based on their docs (please report any mistakes):
 
-| Feature                           | **knip** | [depcheck][16] | [unimported][17] | [ts-unused-exports][18] | [ts-prune][19] | [find-unused-exports][20] |
+| Feature                           | **knip** | [depcheck][33] | [unimported][34] | [ts-unused-exports][35] | [ts-prune][36] | [find-unused-exports][37] |
 | :-------------------------------- | :------: | :------------: | :--------------: | :---------------------: | :------------: | :-----------------------: |
 | Unused files                      |    ✅    |       -        |        ✅        |            -            |       -        |             -             |
 | Unused dependencies               |    ✅    |       ✅       |        ✅        |            -            |       -        |             -             |
 | Unlisted dependencies             |    ✅    |       ✅       |        ✅        |            -            |       -        |             -             |
-| [Custom dependency resolvers][21] |    ✅    |       ✅       |        ❌        |            -            |       -        |             -             |
+| [Custom dependency resolvers][38] |    ✅    |       ✅       |        ❌        |            -            |       -        |             -             |
 | Unused exports                    |    ✅    |       -        |        -         |           ✅            |       ✅       |            ✅             |
 | Unused class members              |    ✅    |       -        |        -         |            -            |       -        |             -             |
 | Unused enum members               |    ✅    |       -        |        -         |            -            |       -        |             -             |
@@ -481,7 +507,7 @@ This table is a work in progress, but here's a first impression. Based on their
 | Custom reporters                  |    ✅    |       -        |        -         |            -            |       -        |             -             |
 | JavaScript support                |    ✅    |       ✅       |        ✅        |            -            |       -        |            ✅             |
 | Configure entry files             |    ✅    |       ❌       |        ✅        |           ❌            |       ❌       |            ❌             |
-| [Support monorepos][22]           |    ✅    |       -        |        -         |            -            |       -        |             -             |
+| [Support monorepos][39]           |    ✅    |       -        |        -         |            -            |       -        |             -             |
 | ESLint plugin available           |    -     |       -        |        -         |           ✅            |       -        |             -             |
 
 ✅ = Supported, ❌ = Not supported, - = Out of scope
@@ -498,27 +524,42 @@ userland territory, much like code linters.
 Knip is Dutch for a "cut". A Dutch expression is "to be ge**knip**t for something", which means to be perfectly suited
 for the job. I'm motivated to make knip perfectly suited for the job of cutting projects to perfection! ✂️
 
-[1]: #reporters
-[2]: #custom-reporters
-[3]: #really-another-unused-filedependencyexport-finder
-[4]: https://labs.openai.com/s/xZQACaLepaKya0PRUPtIN5dC
-[5]: ./assets/cow-with-orange-scissors-van-gogh-style.webp
-[6]: https://github.com/webpro/knip/issues
-[7]: #monorepos
+[1]: #plugins
+[2]: #reporters
+[3]: #custom-reporters
+[4]: #really-another-unused-filedependencyexport-finder
+[5]: https://labs.openai.com/s/xZQACaLepaKya0PRUPtIN5dC
+[6]: ./assets/cow-with-orange-scissors-van-gogh-style.webp
+[7]: https://github.com/webpro/knip/issues
 [8]: ./assets/how-it-works.drawio.svg
-[9]: #json
-[10]: #symbol-default
-[11]: #compact
-[12]: #code-owners
-[13]: #reading-the-report
-[14]: https://github.com/johnkerl/miller
-[15]: https://github.com/kellyjonbrazil/jtbl
-[16]: https://github.com/depcheck/depcheck
-[17]: https://github.com/smeijer/unimported
-[18]: https://github.com/pzavolinsky/ts-unused-exports
-[19]: https://github.com/nadeesha/ts-prune
-[20]: https://github.com/jaydenseric/find-unused-exports
-[21]: #custom-dependency-resolvers
-[22]: #monorepos-1
-[23]: https://github.com/depcheck/depcheck#special
-[24]: #roadmap
+[9]: ./src/plugins/babel
+[10]: ./src/plugins/capacitor
+[11]: ./src/plugins/changesets
+[12]: ./src/plugins/cypress
+[13]: ./src/plugins/eslint
+[14]: ./src/plugins/gatsby
+[15]: ./src/plugins/jest
+[16]: ./src/plugins/mocha
+[17]: ./src/plugins/next
+[18]: ./src/plugins/nx
+[19]: ./src/plugins/playwright
+[20]: ./src/plugins/postcss
+[21]: ./src/plugins/remark
+[22]: ./src/plugins/remix
+[23]: ./src/plugins/rollup
+[24]: ./src/plugins/storybook
+[25]: ./src/plugins/stryker
+[26]: #json
+[27]: #symbol-default
+[28]: #compact
+[29]: #code-owners
+[30]: #reading-the-report
+[31]: https://github.com/johnkerl/miller
+[32]: https://github.com/kellyjonbrazil/jtbl
+[33]: https://github.com/depcheck/depcheck
+[34]: https://github.com/smeijer/unimported
+[35]: https://github.com/pzavolinsky/ts-unused-exports
+[36]: https://github.com/nadeesha/ts-prune
+[37]: https://github.com/jaydenseric/find-unused-exports
+[38]: #custom-dependency-resolvers
+[39]: #monorepos-1

package/dist/cli.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import path from 'node:path';
 import { register } from 'esbuild-register/dist/node.js';
-import { printHelp } from './util/help.js';
 import reporters from './reporters/index.js';
 import { ConfigurationError } from './util/errors.js';
+import { printHelp } from './util/help.js';
 import parsedArgs from './util/parseArgs.js';
 import { measure } from './util/performance.js';
 import { main } from './index.js';
 register();
-const { values: { help, 'no-gitignore': isNoGitIgnore = false, strict: isStrict = false, production: isProduction = false, 'no-progress': noProgress = false, reporter = 'symbols', 'reporter-options': reporterOptions = '', 'max-issues': maxIssues = '0', debug: isDebug = false, }, } = parsedArgs;
+const { values: { debug: isDebug = false, help, 'max-issues': maxIssues = '0', 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': noProgress = false, production: isProduction = false, reporter = 'symbols', 'reporter-options': reporterOptions = '', strict: isStrict = false, tsConfig, }, } = parsedArgs;
 if (help) {
     printHelp();
     process.exit(0);
@@ -20,6 +20,7 @@ const run = async () => {
     try {
         const { report, issues, counters } = await main({
             cwd,
+            tsConfigFile: tsConfig,
             gitignore: !isNoGitIgnore,
             isStrict,
             isProduction,
@@ -30,8 +31,9 @@ const run = async () => {
             .filter(reportGroup => report[reportGroup])
             .reduce((errorCount, reportGroup) => errorCount + counters[reportGroup], 0);
         await measure.print();
-        if (totalErrorCount > Number(maxIssues))
+        if (!noExitCode && totalErrorCount > Number(maxIssues)) {
             process.exit(totalErrorCount);
+        }
     }
     catch (error) {
         if (error instanceof ConfigurationError) {

package/dist/configuration-chief.js

@@ -1,15 +1,16 @@
 import path from 'node:path';
 import micromatch from 'micromatch';
+import { ROOT_WORKSPACE_NAME } from './constants.js';
+import * as plugins from './plugins/index.js';
 import { LocalConfiguration } from './types/validate.js';
 import { arrayify } from './util/array.js';
-import { ROOT_WORKSPACE_NAME } from './util/constants.js';
 import { ConfigurationError } from './util/errors.js';
 import { findFile, loadJSON } from './util/fs.js';
 import { _dirGlob } from './util/glob.js';
 import parsedArgs from './util/parseArgs.js';
 import { resolveIncludedIssueTypes } from './util/resolveIncludedIssueTypes.js';
 import { workspaceSorter } from './util/sort.js';
-const { values: { workspace: rawWorkspaceArg, config: rawConfigArg, include = [], exclude = [], strict: isStrict = false, production: isProduction = false, }, } = parsedArgs;
+const { values: { config: rawConfigArg, workspace: rawWorkspaceArg, include = [], exclude = [], strict: isStrict = false, production: isProduction = false, }, } = parsedArgs;
 const defaultConfig = {
     include: [],
     exclude: [],
@@ -25,23 +26,7 @@ const defaultConfig = {
         },
     },
 };
-const PLUGIN_NAMES = [
-    'babel',
-    'capacitor',
-    'changesets',
-    'cypress',
-    'eslint',
-    'gatsby',
-    'jest',
-    'next',
-    'nx',
-    'playwright',
-    'postcss',
-    'remark',
-    'remix',
-    'rollup',
-    'storybook',
-];
+const PLUGIN_NAMES = Object.keys(plugins);
 export default class ConfigurationChief {
     cwd = process.cwd();
     config;
@@ -103,12 +88,10 @@ export default class ConfigurationChief {
                         const config = isObject ? arrayify(pluginConfig.config) : arrayify(pluginConfig);
                         const entryFiles = isObject && 'entryFiles' in pluginConfig ? arrayify(pluginConfig.entryFiles) : [];
                         const projectFiles = isObject && 'projectFiles' in pluginConfig ? arrayify(pluginConfig.projectFiles) : entryFiles;
-                        const sampleFiles = isObject && 'sampleFiles' in pluginConfig ? arrayify(pluginConfig.sampleFiles) : [];
                         workspaces[workspaceName][pluginName] = {
                             config,
                             entryFiles,
                             projectFiles,
-                            sampleFiles,
                         };
                     }
                 }

package/dist/{util/constants.js → constants.js}

@@ -1,4 +1,4 @@
 export const ROOT_WORKSPACE_NAME = '.';
 export const TEST_FILE_PATTERNS = ['**/*.{test,spec}.{js,jsx,ts,tsx}', '**/__tests__/**/*.{js,jsx,ts,tsx}'];
-export const IGNORED_GLOBAL_BINARIES = ['npm', 'npx', 'node', 'yarn', 'pnpm'];
+export const IGNORED_GLOBAL_BINARIES = ['npm', 'npx', 'node', 'yarn', 'pnpm', 'deno', 'git'];
 export const FIRST_ARGUMENT_AS_BINARY_EXCEPTIONS = ['cross-env', 'dotenv'];

package/dist/index.js

@@ -1,11 +1,11 @@
 import path from 'node:path';
 import ConfigurationChief from './configuration-chief.js';
+import { ROOT_WORKSPACE_NAME } from './constants.js';
 import DependencyDeputy from './dependency-deputy.js';
 import IssueCollector from './issue-collector.js';
 import ProjectPrincipal from './project-principal.js';
 import SourceLab from './source-lab.js';
 import { compact } from './util/array.js';
-import { ROOT_WORKSPACE_NAME } from './util/constants.js';
 import { debugLogObject, debugLogFiles } from './util/debug.js';
 import { _findExternalImportModuleSpecifiers } from './util/externalImports.js';
 import { findFile, loadJSON } from './util/fs.js';
@@ -14,7 +14,7 @@ import { _findDuplicateExportedNames } from './util/project.js';
 import { loadTSConfig } from './util/tsconfig-loader.js';
 import WorkspaceWorker from './workspace-worker.js';
 export const main = async (unresolvedConfiguration) => {
-    const { cwd, gitignore, isStrict, isProduction, isShowProgress } = unresolvedConfiguration;
+    const { cwd, tsConfigFile, gitignore, isStrict, isProduction, isShowProgress } = unresolvedConfiguration;
     const chief = new ConfigurationChief({ cwd });
     const deputy = new DependencyDeputy();
     debugLogObject(1, 'Unresolved configuration', unresolvedConfiguration);
@@ -22,8 +22,6 @@ export const main = async (unresolvedConfiguration) => {
     collector.updateMessage('Reading configuration and manifest files...');
     await chief.loadLocalConfig();
     const workspaces = await chief.getActiveWorkspaces();
-    if (!chief.manifest || !chief.manifestPath)
-        throw new Error('mani');
     debugLogObject(1, 'Included workspaces', workspaces);
     const report = chief.resolveIncludedIssueTypes();
     const workspaceDirs = Object.values(workspaces)
@@ -42,7 +40,7 @@ export const main = async (unresolvedConfiguration) => {
         if (!manifestPath || !manifest)
             continue;
         deputy.addWorkspace({ name, dir, manifestPath, manifest });
-        const tsConfigFilePath = path.join(dir, 'tsconfig.json');
+        const tsConfigFilePath = path.join(dir, tsConfigFile ?? 'tsconfig.json');
         const tsConfig = await loadTSConfig(tsConfigFilePath);
         if (isRoot && tsConfig) {
             principal.tsConfigFilePath = tsConfigFilePath;
@@ -188,15 +186,15 @@ export const main = async (unresolvedConfiguration) => {
                     }
                     else {
                         issue.symbol = deputy.resolvePackageName(issue.symbol);
-                        if (!deputy.isInternalDependency(name, issue.symbol)) {
-                            if (!workspaceDependencies.includes(issue.symbol)) {
-                                if (isStrict) {
-                                    collector.addIssue(issue);
-                                }
-                                else if (!rootDependencies.includes(issue.symbol)) {
-                                    collector.addIssue(issue);
-                                }
-                            }
+                        if (deputy.isInternalDependency(name, issue.symbol))
+                            continue;
+                        if (workspaceDependencies.includes(issue.symbol))
+                            continue;
+                        if (isStrict) {
+                            collector.addIssue(issue);
+                        }
+                        else if (!rootDependencies.includes(issue.symbol)) {
+                            collector.addIssue(issue);
                         }
                     }
                 }

package/dist/npm-scripts/helpers.js

@@ -1,6 +1,6 @@
 import { createRequire } from 'node:module';
 import path from 'node:path';
-import { FIRST_ARGUMENT_AS_BINARY_EXCEPTIONS } from '../util/constants.js';
+import { FIRST_ARGUMENT_AS_BINARY_EXCEPTIONS } from '../constants.js';
 const require = createRequire(process.cwd());
 const normalizeBinaries = (command) => command.replace(/(\.\/)?node_modules\/\.bin\/(\w+)/, '$2').replace(/\$\(npm bin\)\/(\w+)/, '$1');
 const stripEnvironmentVariables = (value) => value.replace(/([A-Z][^ ]*)=([^ ])+ /g, '');

package/dist/npm-scripts/index.js

@@ -1,5 +1,5 @@
+import { IGNORED_GLOBAL_BINARIES } from '../constants.js';
 import { compact } from '../util/array.js';
-import { IGNORED_GLOBAL_BINARIES } from '../util/constants.js';
 import { timerify } from '../util/performance.js';
 import { getBinariesFromScripts, getPackageManifest } from './helpers.js';
 const findManifestDependencies = async (ignoreBinaries, manifest, isRoot, dir, cwd) => {

package/dist/plugins/babel/index.js

@@ -20,22 +20,17 @@ const api = {
     caller: () => true,
 };
 const getDependenciesFromConfig = (config) => {
-    if (config) {
-        const presets = config.presets?.map(preset => (typeof preset === 'string' ? preset : preset[0])).map(resolvePresetName) ?? [];
-        const plugins = config.plugins?.map(plugin => (typeof plugin === 'string' ? plugin : plugin[0])).map(resolvePluginName) ?? [];
-        return compact([...presets, ...plugins]);
-    }
-    return [];
+    const presets = config.presets?.map(preset => (typeof preset === 'string' ? preset : preset[0])).map(resolvePresetName) ?? [];
+    const plugins = config.plugins?.map(plugin => (typeof plugin === 'string' ? plugin : plugin[0])).map(resolvePluginName) ?? [];
+    return compact([...presets, ...plugins]);
 };
 const findBabelDependencies = async (configFilePath, { manifest }) => {
-    if (configFilePath.endsWith('package.json')) {
-        const config = manifest?.babel;
-        return getDependenciesFromConfig(config);
-    }
-    let config = await load(configFilePath);
+    let config = configFilePath.endsWith('package.json')
+        ? manifest.babel
+        : await load(configFilePath);
     if (typeof config === 'function') {
         config = config(api);
     }
-    return getDependenciesFromConfig(config);
+    return config ? getDependenciesFromConfig(config) : [];
 };
 export const findDependencies = timerify(findBabelDependencies);

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

@@ -1,2 +1,4 @@
 import type { ESLintConfig } from './types.js';
+export declare const resolvePluginPackageName: (pluginName: string) => string;
+export declare const customResolvePluginPackageNames: (extend: string) => string | undefined;
 export declare const getDependenciesFromSettings: (settings?: ESLintConfig['settings']) => string[];

package/dist/plugins/eslint/helpers.js

@@ -1,4 +1,25 @@
 import { compact } from '../../util/array.js';
+import { getPackageName } from '../../util/modules.js';
+export const resolvePluginPackageName = (pluginName) => {
+    return pluginName.startsWith('@')
+        ? pluginName.includes('/')
+            ? pluginName
+            : `${pluginName}/eslint-plugin`
+        : `eslint-plugin-${pluginName}`;
+};
+export const customResolvePluginPackageNames = (extend) => {
+    if (extend.includes('/node_modules/'))
+        return getPackageName(extend);
+    if (extend.startsWith('/') || extend.startsWith('.'))
+        return;
+    if (extend.includes(':')) {
+        const pluginName = extend.replace(/^plugin:/, '').replace(/(\/|:).+$/, '');
+        if (pluginName === 'eslint')
+            return;
+        return resolvePluginPackageName(pluginName);
+    }
+    return extend.includes('eslint') ? getPackageName(extend) : resolvePluginPackageName(extend);
+};
 const getImportPluginDependencies = (settings) => {
     const knownKeys = ['typescript'];
     if (Array.isArray(settings))

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

@@ -1,4 +1,5 @@
 import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
 export declare const isEnabled: IsPluginEnabledCallback;
 export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const ENTRY_FILE_PATTERNS: string[];
 export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/eslint/index.js

@@ -1,39 +1,36 @@
-import path from 'node:path';
 import { ESLint } from 'eslint';
 import { compact } from '../../util/array.js';
+import { _firstGlob } from '../../util/glob.js';
+import load from '../../util/loader.js';
 import { getPackageName } from '../../util/modules.js';
 import { timerify } from '../../util/performance.js';
-import { getDependenciesFromSettings } from './helpers.js';
-export const isEnabled = ({ dependencies }) => {
-    return dependencies.has('eslint');
-};
-export const CONFIG_FILE_PATTERNS = ['eslint.config.js', '.eslintrc', '.eslintrc.json', '.eslintrc.js'];
-const SAMPLE_FILE_PATHS = ['__placeholder__.js', '__placeholder__.ts'];
-const resolvePluginPackageName = (pluginName) => {
-    return pluginName.startsWith('@')
-        ? pluginName.includes('/')
-            ? pluginName
-            : `${pluginName}/eslint-plugin`
-        : `eslint-plugin-${pluginName}`;
-};
-const findESLintDependencies = async (configFilePath, { cwd, config }) => {
-    if (path.basename(configFilePath) === 'eslint.config.js') {
+import { resolvePluginPackageName, customResolvePluginPackageNames, getDependenciesFromSettings } from './helpers.js';
+export const isEnabled = ({ dependencies }) => dependencies.has('eslint');
+export const CONFIG_FILE_PATTERNS = ['.eslintrc', '.eslintrc.{js,json}', 'package.json'];
+export const ENTRY_FILE_PATTERNS = ['eslint.config.js'];
+const findESLintDependencies = async (configFilePath, { cwd, manifest, workspaceConfig }) => {
+    if (configFilePath.endsWith('package.json') && !manifest.eslintConfig)
         return [];
-    }
-    else {
-        const engine = new ESLint({ cwd, overrideConfigFile: configFilePath, useEslintrc: false });
-        const calculateConfigForFile = async (sampleFile) => await engine.calculateConfigForFile(sampleFile);
-        const sampleFiles = config?.sampleFiles.length > 0 ? config.sampleFiles : SAMPLE_FILE_PATHS;
-        const dependencies = await Promise.all(sampleFiles.map(calculateConfigForFile)).then(configs => configs.flatMap(config => {
-            if (!config)
-                return [];
-            const plugins = config.plugins?.map(resolvePluginPackageName) ?? [];
-            const parsers = config.parser ? [config.parser] : [];
-            const extraParsers = config.parserOptions?.babelOptions?.presets ?? [];
-            const settings = config.settings ? getDependenciesFromSettings(config.settings) : [];
-            return [...parsers, ...extraParsers, ...plugins, ...settings].map(getPackageName);
-        }));
-        return compact(dependencies.flat());
-    }
+    const config = configFilePath.endsWith('package.json')
+        ? manifest.eslintConfig
+        : await load(configFilePath);
+    const rootExtends = config?.extends ? [config.extends].flat().map(customResolvePluginPackageNames) : [];
+    const patterns = [workspaceConfig.entryFiles, ...(config?.overrides?.map(overrides => overrides.files) ?? [])];
+    const samples = await Promise.all(patterns.map(patterns => _firstGlob({ patterns, cwd })));
+    const sampleFilePaths = samples
+        .filter((filePath) => typeof filePath !== 'undefined')
+        .map(String);
+    const engine = new ESLint({ cwd, overrideConfigFile: configFilePath, useEslintrc: false });
+    const calculateConfigForFile = async (sampleFile) => await engine.calculateConfigForFile(sampleFile);
+    const dependencies = await Promise.all(sampleFilePaths.map(calculateConfigForFile)).then(configs => configs.flatMap(config => {
+        if (!config)
+            return [];
+        const plugins = config.plugins?.map(resolvePluginPackageName) ?? [];
+        const parsers = config.parser ? [config.parser] : [];
+        const extraParsers = config.parserOptions?.babelOptions?.presets ?? [];
+        const settings = config.settings ? getDependenciesFromSettings(config.settings) : [];
+        return [...parsers, ...extraParsers, ...plugins, ...settings].map(getPackageName);
+    }));
+    return compact([...rootExtends, ...dependencies.flat()]);
 };
 export const findDependencies = timerify(findESLintDependencies);

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

@@ -1,4 +1,5 @@
 export type ESLintConfig = {
+    extends?: string | string[];
     parser?: string;
     parserOptions?: {
         babelOptions?: {
@@ -7,4 +8,7 @@ export type ESLintConfig = {
     };
     plugins?: string[];
     settings?: Record<string, Record<string, unknown>>;
+    overrides?: {
+        files: string[];
+    }[];
 };

package/dist/plugins/index.d.ts

@@ -5,6 +5,7 @@ export * as cypress from './cypress/index.js';
 export * as eslint from './eslint/index.js';
 export * as gatsby from './gatsby/index.js';
 export * as jest from './jest/index.js';
+export * as mocha from './mocha/index.js';
 export * as next from './next/index.js';
 export * as nx from './nx/index.js';
 export * as playwright from './playwright/index.js';
@@ -13,3 +14,4 @@ export * as remark from './remark/index.js';
 export * as remix from './remix/index.js';
 export * as rollup from './rollup/index.js';
 export * as storybook from './storybook/index.js';
+export * as stryker from './stryker/index.js';