knip 1.0.0-alpha.0 → 1.0.0-alpha.2

package/README.md

@@ -20,8 +20,8 @@ The dots don't connect themselves. This is where Knip comes in:
 - [x] Finds used dependencies not listed in `package.json`.
 - [x] Finds duplicate exports.
 - [x] Finds unused members of classes and enums
-- [x] Supports workspaces/monorepos
-- [x] Growing list of plugins (= less to configure and custom dependency resolvers)
+- [x] Built-in support for monorepos (workspaces)
+- [x] Growing list of built-in plugins (= less to configure and custom dependency resolvers)
 - [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] Run Knip as part of your CI environment to detect issues and prevent regressions.

package/dist/configuration-chief.js

@@ -18,8 +18,8 @@ const defaultConfig = {
     ignoreWorkspaces: [],
     workspaces: {
         [ROOT_WORKSPACE_NAME]: {
-            entryFiles: ['index.{js,ts}', 'src/index.{js,ts}'],
-            projectFiles: ['**/*.ts'],
+            entryFiles: ['index.{js,ts,tsx}', 'src/index.{js,ts,tsx}'],
+            projectFiles: ['**/*.{js,ts,tsx}'],
             ignore: [],
             paths: {},
         },
@@ -103,10 +103,12 @@ 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/dependency-deputy.d.ts

@@ -1,4 +1,5 @@
 import { WorkspaceConfiguration } from './types/config.js';
+import type { Issue } from './types/issues.js';
 import type { WorkspaceManifests } from './types/workspace.js';
 import type { PackageJson } from 'type-fest';
 export default class DependencyDeputy {
@@ -8,14 +9,12 @@ export default class DependencyDeputy {
     referencedDependencies: Map<string, Set<string>>;
     peerDependencies: Map<string, Map<string, Set<string>>>;
     tsConfigPathGlobs: Map<string, string[]>;
-    isProduction: boolean;
     constructor();
-    addWorkspace({ name, dir, manifestPath, manifest, isProduction, }: {
+    addWorkspace({ name, dir, manifestPath, manifest, }: {
         name: string;
         dir: string;
         manifestPath: string;
         manifest: PackageJson;
-        isProduction: boolean;
     }): void;
     cancelWorkspace(workspaceName: string): void;
     getManifest(workspaceName: string): PackageJson | undefined;
@@ -47,13 +46,7 @@ export default class DependencyDeputy {
     resolvePackageName(moduleSpecifier: string): string;
     private isInDependencies;
     settleDependencyIssues(): {
-        dependencyIssues: {
-            filePath: string;
-            symbol: string;
-        }[];
-        devDependencyIssues: {
-            filePath: string;
-            symbol: string;
-        }[];
+        dependencyIssues: Issue[];
+        devDependencyIssues: Issue[];
     };
 }

package/dist/dependency-deputy.js

@@ -1,5 +1,6 @@
 import { isBuiltin } from 'node:module';
 import micromatch from 'micromatch';
+import { isDefinitelyTyped, getDefinitelyTypedPackage } from './util/modules.js';
 const IGNORE_DEFINITELY_TYPED = ['node'];
 export default class DependencyDeputy {
     _manifests = new Map();
@@ -8,13 +9,12 @@ export default class DependencyDeputy {
     referencedDependencies;
     peerDependencies;
     tsConfigPathGlobs = new Map();
-    isProduction = false;
     constructor() {
         this.referencedDependencies = new Map();
         this.peerDependencies = new Map();
         this.canceledWorkspaces = new Set();
     }
-    addWorkspace({ name, dir, manifestPath, manifest, isProduction, }) {
+    addWorkspace({ name, dir, manifestPath, manifest, }) {
         const scripts = Object.values(manifest.scripts ?? {});
         const dependencies = Object.keys(manifest.dependencies ?? {});
         const peerDependencies = Object.keys(manifest.peerDependencies ?? {});
@@ -33,7 +33,6 @@ export default class DependencyDeputy {
             productionDependencies,
             allDependencies: [...productionDependencies, ...devDependencies],
         });
-        this.isProduction = isProduction;
     }
     cancelWorkspace(workspaceName) {
         this.canceledWorkspaces.add(workspaceName);
@@ -71,12 +70,14 @@ export default class DependencyDeputy {
         const packageName = this.resolvePackageName(moduleSpecifier);
         const workspaceNames = isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
         const closestWorkspaceName = workspaceNames.find(name => this.isInDependencies(name, packageName));
-        if (closestWorkspaceName) {
-            this.addReferencedDependency(closestWorkspaceName, packageName);
-        }
-        else {
-            return moduleSpecifier;
+        const typesPackageName = !isDefinitelyTyped(packageName) && getDefinitelyTypedPackage(packageName);
+        const closestWorkspaceNameForTypes = typesPackageName && workspaceNames.find(name => this.isInDependencies(name, typesPackageName));
+        if (closestWorkspaceName || closestWorkspaceNameForTypes) {
+            closestWorkspaceName && this.addReferencedDependency(closestWorkspaceName, packageName);
+            closestWorkspaceNameForTypes && this.addReferencedDependency(closestWorkspaceNameForTypes, typesPackageName);
+            return;
         }
+        return moduleSpecifier;
     }
     isInternalDependency(workspaceName, moduleSpecifier) {
         if (moduleSpecifier.startsWith('/') || moduleSpecifier.startsWith('.'))
@@ -106,15 +107,13 @@ export default class DependencyDeputy {
                 continue;
             const referencedDependencies = this.referencedDependencies.get(workspaceName);
             const isUnreferencedDependency = (dependency) => {
+                if (referencedDependencies?.has(dependency))
+                    return false;
                 const [scope, typedDependency] = dependency.split('/');
                 if (scope === '@types') {
                     if (IGNORE_DEFINITELY_TYPED.includes(typedDependency))
                         return false;
-                    if (referencedDependencies?.has(dependency))
-                        return false;
-                    const [scope, name] = typedDependency.split('__');
-                    const typedPackageName = scope && name ? `@${scope}/${name}` : typedDependency;
-                    return referencedDependencies ? !referencedDependencies.has(typedPackageName) : false;
+                    return !referencedDependencies?.has(typedDependency);
                 }
                 if (!referencedDependencies?.has(dependency)) {
                     const peerDependencies = Array.from(this.peerDependencies.get(workspaceName)?.get(dependency) ?? []);
@@ -124,10 +123,10 @@ export default class DependencyDeputy {
             };
             this.getProductionDependencies(workspaceName)
                 .filter(isUnreferencedDependency)
-                .forEach(symbol => dependencyIssues.push({ filePath: manifestPath, symbol }));
+                .forEach(symbol => dependencyIssues.push({ type: 'dependencies', filePath: manifestPath, symbol }));
             this.getDevDependencies(workspaceName)
                 .filter(isUnreferencedDependency)
-                .forEach(symbol => devDependencyIssues.push({ filePath: manifestPath, symbol }));
+                .forEach(symbol => devDependencyIssues.push({ type: 'devDependencies', filePath: manifestPath, symbol }));
         }
         return { dependencyIssues, devDependencyIssues };
     }

package/dist/index.js

@@ -7,8 +7,10 @@ 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';
 import { _glob } from './util/glob.js';
+import { _findDuplicateExportedNames } from './util/project.js';
 import { loadTSConfig } from './util/tsconfig-loader.js';
 import WorkspaceWorker from './workspace-worker.js';
 export const main = async (unresolvedConfiguration) => {
@@ -16,7 +18,7 @@ export const main = async (unresolvedConfiguration) => {
     const chief = new ConfigurationChief({ cwd });
     const deputy = new DependencyDeputy();
     debugLogObject(1, 'Unresolved configuration', unresolvedConfiguration);
-    const collector = new IssueCollector({ cwd, isShowProgress, isProduction });
+    const collector = new IssueCollector({ cwd, isShowProgress });
     collector.updateMessage('Reading configuration and manifest files...');
     await chief.loadLocalConfig();
     const workspaces = await chief.getActiveWorkspaces();
@@ -30,7 +32,7 @@ export const main = async (unresolvedConfiguration) => {
     const negatedWorkspacePatterns = Object.values(workspaces)
         .filter(workspace => workspace.name !== ROOT_WORKSPACE_NAME)
         .map(workspace => `!${workspace.name}`);
-    const lab = new SourceLab({ issueManager: collector, report, workspaceDirs });
+    const lab = new SourceLab({ report, workspaceDirs });
     const principal = new ProjectPrincipal();
     for (const { name, dir, config, ancestors } of workspaces) {
         const isRoot = name === ROOT_WORKSPACE_NAME;
@@ -39,7 +41,7 @@ export const main = async (unresolvedConfiguration) => {
         const manifest = isRoot ? chief.manifest : manifestPath && (await loadJSON(manifestPath));
         if (!manifestPath || !manifest)
             continue;
-        deputy.addWorkspace({ name, dir, manifestPath, manifest, isProduction });
+        deputy.addWorkspace({ name, dir, manifestPath, manifest });
         const tsConfigFilePath = path.join(dir, 'tsconfig.json');
         const tsConfig = await loadTSConfig(tsConfigFilePath);
         if (isRoot && tsConfig) {
@@ -189,10 +191,10 @@ export const main = async (unresolvedConfiguration) => {
                         if (!deputy.isInternalDependency(name, issue.symbol)) {
                             if (!workspaceDependencies.includes(issue.symbol)) {
                                 if (isStrict) {
-                                    collector.addIssue('unlisted', issue);
+                                    collector.addIssue(issue);
                                 }
                                 else if (!rootDependencies.includes(issue.symbol)) {
-                                    collector.addIssue('unlisted', issue);
+                                    collector.addIssue(issue);
                                 }
                             }
                         }
@@ -207,23 +209,34 @@ export const main = async (unresolvedConfiguration) => {
     collector.addFilesIssues(unreferencedProductionFiles);
     collector.updateMessage('Connecting the dots...');
     usedProductionFiles.forEach(sourceFile => {
+        collector.counters.processed++;
         const filePath = sourceFile.getFilePath();
         const workspaceDir = workspaceDirs.find(workspaceDir => filePath.startsWith(workspaceDir));
         const workspace = workspaces.find(workspace => workspace.dir === workspaceDir);
-        const externalModuleSpecifiers = lab.analyzeSourceFile(sourceFile);
-        if (workspace) {
+        if (workspace && (report.dependencies || report.unlisted)) {
+            const externalModuleSpecifiers = _findExternalImportModuleSpecifiers(sourceFile);
             externalModuleSpecifiers.forEach(moduleSpecifier => {
                 const unlistedDependency = deputy.maybeAddListedReferencedDependency(workspace, moduleSpecifier, isStrict);
                 if (unlistedDependency)
-                    collector.addIssue('unlisted', { filePath, symbol: unlistedDependency });
+                    collector.addIssue({ type: 'unlisted', filePath, symbol: unlistedDependency });
             });
         }
+        if (report.duplicates) {
+            const duplicateExports = _findDuplicateExportedNames(sourceFile);
+            duplicateExports.forEach(symbols => {
+                const symbol = symbols.join('|');
+                collector.addIssue({ type: 'duplicates', filePath, symbol, symbols });
+            });
+        }
+        const issues = lab.analyzeSourceFile(sourceFile);
+        issues.forEach(issue => issue.type && collector.addIssue(issue));
     });
     collector.removeProgress();
-    const { dependencyIssues, devDependencyIssues } = deputy.settleDependencyIssues();
-    dependencyIssues.forEach(issue => collector.addIssue('dependencies', issue));
-    if (!isProduction) {
-        devDependencyIssues.forEach(issue => collector.addIssue('devDependencies', issue));
+    if (report.dependencies) {
+        const { dependencyIssues, devDependencyIssues } = deputy.settleDependencyIssues();
+        dependencyIssues.forEach(issue => collector.addIssue(issue));
+        if (!isProduction)
+            devDependencyIssues.forEach(issue => collector.addIssue(issue));
     }
     const { issues, counters } = collector.getIssues();
     debugLogObject(3, 'Issues', issues);

package/dist/issue-collector.d.ts

@@ -1,9 +1,8 @@
 import { LineRewriter } from './util/log.js';
-import type { Issue, SymbolIssueType, Report } from './types/issues.js';
+import type { Issue, Report } from './types/issues.js';
 type IssueCollectorOptions = {
     cwd: string;
     isShowProgress?: boolean;
-    isProduction?: boolean;
     report?: Report;
 };
 export default class IssueCollector {
@@ -15,12 +14,11 @@ export default class IssueCollector {
     referencedFiles: Set<string>;
     cwd: string;
     isShowProgress: boolean;
-    isProduction: boolean;
-    constructor({ cwd, isShowProgress, isProduction, report }: IssueCollectorOptions);
+    constructor({ cwd, isShowProgress, report }: IssueCollectorOptions);
     setIsShowProgress(isShowProgress: boolean): void;
     setProjectFilesCount(count: number): void;
     addFilesIssues(filePaths: Set<string>): void;
-    addIssue(issueType: SymbolIssueType, issue: Issue): void;
+    addIssue(issue: Issue): void;
     setReport(report: Report): void;
     updateMessage(message: string): void;
     updateProgress(issue?: Issue): void;

package/dist/issue-collector.js

@@ -11,10 +11,8 @@ export default class IssueCollector {
     referencedFiles;
     cwd;
     isShowProgress = false;
-    isProduction = false;
-    constructor({ cwd, isShowProgress = false, isProduction = false, report }) {
+    constructor({ cwd, isShowProgress = false, report }) {
         this.lineRewriter = new LineRewriter();
-        this.isProduction = isProduction;
         this.cwd = cwd;
         this.setIsShowProgress(isShowProgress);
         this.report = report ?? initReport();
@@ -38,13 +36,13 @@ export default class IssueCollector {
             }
         });
     }
-    addIssue(issueType, issue) {
+    addIssue(issue) {
         issue.filePath = path.relative(this.cwd, issue.filePath);
         const key = relative(issue.filePath);
-        this.issues[issueType][key] = this.issues[issueType][key] ?? {};
-        if (!this.issues[issueType][key][issue.symbol]) {
-            this.issues[issueType][key][issue.symbol] = issue;
-            this.counters[issueType]++;
+        this.issues[issue.type][key] = this.issues[issue.type][key] ?? {};
+        if (!this.issues[issue.type][key][issue.symbol]) {
+            this.issues[issue.type][key][issue.symbol] = issue;
+            this.counters[issue.type]++;
             this.updateProgress(issue);
         }
     }

package/dist/plugins/eslint/index.js

@@ -8,6 +8,7 @@ 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('/')
@@ -15,16 +16,15 @@ const resolvePluginPackageName = (pluginName) => {
             : `${pluginName}/eslint-plugin`
         : `eslint-plugin-${pluginName}`;
 };
-const findESLintDependencies = async (configFilePath, { cwd }) => {
+const findESLintDependencies = async (configFilePath, { cwd, config }) => {
     if (path.basename(configFilePath) === 'eslint.config.js') {
         return [];
     }
     else {
         const engine = new ESLint({ cwd, overrideConfigFile: configFilePath, useEslintrc: false });
-        const jsConfig = await engine.calculateConfigForFile('__placeholder__.js');
-        const tsConfig = await engine.calculateConfigForFile('__placeholder__.ts');
-        const tsxConfig = await engine.calculateConfigForFile('__placeholder__.spec.tsx');
-        const dependencies = [jsConfig, tsConfig, tsxConfig].map(config => {
+        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) ?? [];
@@ -32,7 +32,7 @@ const findESLintDependencies = async (configFilePath, { cwd }) => {
             const extraParsers = config.parserOptions?.babelOptions?.presets ?? [];
             const settings = config.settings ? getDependenciesFromSettings(config.settings) : [];
             return [...parsers, ...extraParsers, ...plugins, ...settings].map(getPackageName);
-        });
+        }));
         return compact(dependencies.flat());
     }
 };

package/dist/plugins/rollup/index.js

@@ -1,3 +1,3 @@
 export const isEnabled = ({ dependencies }) => dependencies.has('rollup');
 export const CONFIG_FILE_PATTERNS = [];
-export const ENTRY_FILE_PATTERNS = ['rollup.config.{js,mjs}'];
+export const ENTRY_FILE_PATTERNS = ['rollup.config.{js,mjs,ts}'];

package/dist/reporters/codeowners.js

@@ -43,20 +43,20 @@ export default ({ report, issues, options }) => {
     const fallbackOwner = dependenciesOwner;
     const calcFileOwnership = (filePath) => codeownersEngine.calcFileOwnership(relative(filePath))[0] ?? fallbackOwner;
     const addOwner = (issue) => ({ ...issue, owner: calcFileOwnership(issue.filePath) });
-    for (const [reportType, isReportType] of Object.entries(report)) {
+    for (const [type, isReportType] of Object.entries(report)) {
         if (isReportType) {
-            const title = reportMultipleGroups && ISSUE_TYPE_TITLE[reportType];
-            if (issues[reportType] instanceof Set) {
-                const toIssue = (filePath) => ({ filePath, symbol: filePath });
-                const issuesForType = Array.from(issues[reportType]).map(toIssue);
+            const title = reportMultipleGroups && ISSUE_TYPE_TITLE[type];
+            if (issues[type] instanceof Set) {
+                const toIssue = (filePath) => ({ type, filePath, symbol: filePath });
+                const issuesForType = Array.from(issues[type]).map(toIssue);
                 logIssueSet(issuesForType.map(addOwner), title);
             }
-            else if (reportType === 'duplicates') {
-                const issuesForType = Object.values(issues[reportType]).map(Object.values).flat().map(addOwner);
+            else if (type === 'duplicates') {
+                const issuesForType = Object.values(issues[type]).map(Object.values).flat().map(addOwner);
                 logIssueRecord(issuesForType, title);
             }
             else {
-                const issuesForType = Object.values(issues[reportType]).map(issues => {
+                const issuesForType = Object.values(issues[type]).map(issues => {
                     const items = Object.values(issues);
                     return addOwner({ ...items[0], symbols: items.map(issue => issue.symbol) });
                 });

package/dist/source-lab.d.ts

@@ -1,22 +1,19 @@
 import { SourceFile } from 'ts-morph';
-import IssueCollector from './issue-collector.js';
-import type { Report } from './types/issues.js';
+import type { Report, Issue } from './types/issues.js';
 type FileLabOptions = {
-    issueManager: IssueCollector;
     report: Report;
     workspaceDirs: string[];
 };
 export default class SourceLab {
-    issueManager: IssueCollector;
     report: Report;
     workspaceDirs: string[];
     skipExportsAnalysis: Set<unknown>;
     isReportExports: boolean;
     isReportValues: boolean;
     isReportTypes: boolean;
-    constructor({ issueManager, report, workspaceDirs }: FileLabOptions);
+    constructor({ report, workspaceDirs }: FileLabOptions);
     skipExportsAnalysisFor(filePath: string | string[]): void;
-    analyzeSourceFile(sourceFile: SourceFile): string[];
+    analyzeSourceFile(sourceFile: SourceFile): Set<Issue>;
     private analyzeExports;
 }
 export {};

package/dist/source-lab.js

@@ -1,18 +1,15 @@
 import { ts, Node } from 'ts-morph';
-import { _findExternalImportModuleSpecifiers } from './util/externalImports.js';
 import { findUnusedClassMembers, findUnusedEnumMembers } from './util/members.js';
-import { _findDuplicateExportedNames, _hasReferencingDefaultImport, _findReferencingNamespaceNodes, _getExportedDeclarations, _findReferences, hasExternalReferences, } from './util/project.js';
+import { _hasReferencingDefaultImport, _findReferencingNamespaceNodes, _getExportedDeclarations, _findReferences, hasExternalReferences, } from './util/project.js';
 import { getType } from './util/type.js';
 export default class SourceLab {
-    issueManager;
     report;
     workspaceDirs;
     skipExportsAnalysis;
     isReportExports;
     isReportValues;
     isReportTypes;
-    constructor({ issueManager, report, workspaceDirs }) {
-        this.issueManager = issueManager;
+    constructor({ report, workspaceDirs }) {
         this.report = report;
         this.workspaceDirs = workspaceDirs;
         this.skipExportsAnalysis = new Set();
@@ -27,30 +24,18 @@ export default class SourceLab {
             filePath.forEach(filePath => this.skipExportsAnalysis.add(filePath));
     }
     analyzeSourceFile(sourceFile) {
-        const im = this.issueManager;
-        const report = this.report;
-        let externalModuleSpecifiers = [];
-        im.counters.processed++;
+        const issues = new Set();
         const filePath = sourceFile.getFilePath();
-        if (report.dependencies || report.unlisted) {
-            externalModuleSpecifiers = _findExternalImportModuleSpecifiers(sourceFile);
-        }
-        if (report.duplicates) {
-            const duplicateExports = _findDuplicateExportedNames(sourceFile);
-            duplicateExports.forEach(symbols => {
-                const symbol = symbols.join('|');
-                im.addIssue('duplicates', { filePath, symbol, symbols });
-            });
-        }
         if (this.skipExportsAnalysis.has(filePath))
-            return externalModuleSpecifiers;
+            return issues;
         if (this.isReportExports) {
-            this.analyzeExports(sourceFile);
+            const exportsIssues = this.analyzeExports(sourceFile);
+            exportsIssues.forEach(issue => issues.add(issue));
         }
-        return externalModuleSpecifiers;
+        return issues;
     }
     analyzeExports(sourceFile) {
-        const im = this.issueManager;
+        const issues = new Set();
         const report = this.report;
         const filePath = sourceFile.getFilePath();
         const exportDeclarations = _getExportedDeclarations(sourceFile);
@@ -70,7 +55,8 @@ export default class SourceLab {
                 if (declaration.isKind(ts.SyntaxKind.EnumDeclaration)) {
                     identifier = declaration.getFirstChildByKind(ts.SyntaxKind.Identifier);
                     if (report.enumMembers) {
-                        findUnusedEnumMembers(declaration, filePath).forEach(member => im.addIssue('enumMembers', {
+                        findUnusedEnumMembers(declaration, filePath).forEach(member => issues.add({
+                            type: 'enumMembers',
                             filePath,
                             symbol: member.getName(),
                             parentSymbol: identifier?.getText(),
@@ -80,7 +66,8 @@ export default class SourceLab {
                 else if (declaration.isKind(ts.SyntaxKind.ClassDeclaration)) {
                     identifier = declaration.getFirstChildByKind(ts.SyntaxKind.Identifier);
                     if (report.classMembers) {
-                        findUnusedClassMembers(declaration, filePath).forEach(member => im.addIssue('classMembers', {
+                        findUnusedClassMembers(declaration, filePath).forEach(member => issues.add({
+                            type: 'classMembers',
                             filePath,
                             symbol: member.getName(),
                             parentSymbol: identifier?.getText(),
@@ -119,38 +106,31 @@ export default class SourceLab {
                 }
                 if (identifier || fakeIdentifier) {
                     const identifierText = fakeIdentifier ?? identifier?.getText() ?? '*';
-                    if (report.exports && im.issues.exports[filePath]?.[identifierText])
-                        return;
-                    if (report.types && im.issues.types[filePath]?.[identifierText])
-                        return;
-                    if (report.nsExports && im.issues.nsExports[filePath]?.[identifierText])
-                        return;
-                    if (report.nsTypes && im.issues.nsTypes[filePath]?.[identifierText])
-                        return;
                     const refs = _findReferences(identifier);
                     if (refs.length === 0) {
-                        im.addIssue('exports', { filePath, symbol: identifierText });
+                        issues.add({ type: 'exports', filePath, symbol: identifierText });
                     }
                     else {
                         if (hasExternalReferences(refs, filePath))
                             return;
                         if (_findReferencingNamespaceNodes(sourceFile).length > 0) {
                             if (type) {
-                                im.addIssue('nsTypes', { filePath, symbol: identifierText, symbolType: type });
+                                issues.add({ type: 'nsTypes', filePath, symbol: identifierText, symbolType: type });
                             }
                             else {
-                                im.addIssue('nsExports', { filePath, symbol: identifierText });
+                                issues.add({ type: 'nsExports', filePath, symbol: identifierText });
                             }
                         }
                         else if (type) {
-                            im.addIssue('types', { filePath, symbol: identifierText, symbolType: type });
+                            issues.add({ type: 'types', filePath, symbol: identifierText, symbolType: type });
                         }
                         else {
-                            im.addIssue('exports', { filePath, symbol: identifierText });
+                            issues.add({ type: 'exports', filePath, symbol: identifierText });
                         }
                     }
                 }
             });
         });
+        return issues;
     }
 }

package/dist/types/config.d.ts

@@ -3,6 +3,7 @@ export interface PluginConfiguration {
     config: NormalizedGlob;
     entryFiles: NormalizedGlob;
     projectFiles: NormalizedGlob;
+    sampleFiles: NormalizedGlob;
 }
 interface PluginsConfiguration {
     babel: PluginConfiguration;

package/dist/types/issues.d.ts

@@ -1,5 +1,6 @@
 type SymbolType = 'type' | 'interface' | 'enum';
 export type Issue = {
+    type: SymbolIssueType;
     filePath: string;
     symbol: string;
     symbols?: string[];

package/dist/types/plugins.d.ts

@@ -1,4 +1,5 @@
 import { PackageJson } from 'type-fest';
+import { PluginConfiguration } from './config.js';
 type IsPluginEnabledCallbackOptions = {
     manifest: PackageJson;
     dependencies: Set<string>;
@@ -7,5 +8,6 @@ export type IsPluginEnabledCallback = (options: IsPluginEnabledCallbackOptions)
 export type GenericPluginCallback = (configFilePath: string, { cwd, manifest }: {
     cwd: string;
     manifest: PackageJson;
+    config: PluginConfiguration;
 }) => Promise<string[]> | string[];
 export {};

package/dist/types/validate.d.ts

@@ -85,16 +85,19 @@ export declare const LocalConfiguration: z.ZodObject<z.extendShape<z.extendShape
             entryFiles: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
             productionEntryFiles: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
             projectFiles: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+            sampleFiles: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
         }, "strip", z.ZodTypeAny, {
             config?: string | string[] | undefined;
             entryFiles?: string | string[] | undefined;
             projectFiles?: string | string[] | undefined;
             productionEntryFiles?: string | string[] | undefined;
+            sampleFiles?: string | string[] | undefined;
         }, {
             config?: string | string[] | undefined;
             entryFiles?: string | string[] | undefined;
             projectFiles?: string | string[] | undefined;
             productionEntryFiles?: string | string[] | undefined;
+            sampleFiles?: string | string[] | undefined;
         }>]>>;
         gatsby: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
             config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
@@ -290,6 +293,7 @@ export declare const LocalConfiguration: z.ZodObject<z.extendShape<z.extendShape
             entryFiles?: string | string[] | undefined;
             projectFiles?: string | string[] | undefined;
             productionEntryFiles?: string | string[] | undefined;
+            sampleFiles?: string | string[] | undefined;
         } | undefined;
         gatsby?: string | string[] | {
             config?: string | string[] | undefined;
@@ -385,6 +389,7 @@ export declare const LocalConfiguration: z.ZodObject<z.extendShape<z.extendShape
             entryFiles?: string | string[] | undefined;
             projectFiles?: string | string[] | undefined;
             productionEntryFiles?: string | string[] | undefined;
+            sampleFiles?: string | string[] | undefined;
         } | undefined;
         gatsby?: string | string[] | {
             config?: string | string[] | undefined;
@@ -517,16 +522,19 @@ export declare const LocalConfiguration: z.ZodObject<z.extendShape<z.extendShape
         entryFiles: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
         productionEntryFiles: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
         projectFiles: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        sampleFiles: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
     }, "strip", z.ZodTypeAny, {
         config?: string | string[] | undefined;
         entryFiles?: string | string[] | undefined;
         projectFiles?: string | string[] | undefined;
         productionEntryFiles?: string | string[] | undefined;
+        sampleFiles?: string | string[] | undefined;
     }, {
         config?: string | string[] | undefined;
         entryFiles?: string | string[] | undefined;
         projectFiles?: string | string[] | undefined;
         productionEntryFiles?: string | string[] | undefined;
+        sampleFiles?: string | string[] | undefined;
     }>]>>;
     gatsby: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
         config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
@@ -726,6 +734,7 @@ export declare const LocalConfiguration: z.ZodObject<z.extendShape<z.extendShape
         entryFiles?: string | string[] | undefined;
         projectFiles?: string | string[] | undefined;
         productionEntryFiles?: string | string[] | undefined;
+        sampleFiles?: string | string[] | undefined;
     } | undefined;
     gatsby?: string | string[] | {
         config?: string | string[] | undefined;
@@ -821,6 +830,7 @@ export declare const LocalConfiguration: z.ZodObject<z.extendShape<z.extendShape
             entryFiles?: string | string[] | undefined;
             projectFiles?: string | string[] | undefined;
             productionEntryFiles?: string | string[] | undefined;
+            sampleFiles?: string | string[] | undefined;
         } | undefined;
         gatsby?: string | string[] | {
             config?: string | string[] | undefined;
@@ -921,6 +931,7 @@ export declare const LocalConfiguration: z.ZodObject<z.extendShape<z.extendShape
         entryFiles?: string | string[] | undefined;
         projectFiles?: string | string[] | undefined;
         productionEntryFiles?: string | string[] | undefined;
+        sampleFiles?: string | string[] | undefined;
     } | undefined;
     gatsby?: string | string[] | {
         config?: string | string[] | undefined;
@@ -1016,6 +1027,7 @@ export declare const LocalConfiguration: z.ZodObject<z.extendShape<z.extendShape
             entryFiles?: string | string[] | undefined;
             projectFiles?: string | string[] | undefined;
             productionEntryFiles?: string | string[] | undefined;
+            sampleFiles?: string | string[] | undefined;
         } | undefined;
         gatsby?: string | string[] | {
             config?: string | string[] | undefined;

package/dist/types/validate.js

@@ -21,12 +21,22 @@ const pluginWithEntryFilesSchema = z.union([
         projectFiles: globSchema.optional(),
     }),
 ]);
+const pluginWithSampleFilesSchema = z.union([
+    globSchema,
+    z.object({
+        config: globSchema.optional(),
+        entryFiles: globSchema.optional(),
+        productionEntryFiles: globSchema.optional(),
+        projectFiles: globSchema.optional(),
+        sampleFiles: globSchema.optional(),
+    }),
+]);
 const pluginsConfigurationSchema = z.object({
     babel: pluginWithEntryFilesSchema,
     capacitor: pluginWithEntryFilesSchema,
     changesets: pluginWithEntryFilesSchema,
     cypress: pluginWithEntryFilesSchema,
-    eslint: pluginWithEntryFilesSchema,
+    eslint: pluginWithSampleFilesSchema,
     gatsby: pluginWithEntryFilesSchema,
     jest: pluginWithEntryFilesSchema,
     next: pluginWithEntryFilesSchema,

package/dist/util/glob.d.ts

@@ -1,4 +1,5 @@
 export declare const negate: (pattern: string) => string;
+export declare const removeProductionSuffix: (pattern: string) => string;
 export declare const _glob: ({ cwd, workingDir, patterns, ignore, gitignore, }: {
     cwd: string;
     workingDir?: string | undefined;

package/dist/util/glob.js

@@ -10,6 +10,7 @@ const prependDirToPattern = (workingDir, pattern) => {
     return path.posix.join(workingDir, pattern);
 };
 export const negate = (pattern) => `!${pattern}`;
+export const removeProductionSuffix = (pattern) => pattern.replace(/!$/, '');
 const sortNegatedLast = (a, b) => (a.startsWith('!') ? 1 : b.startsWith('!') ? -1 : 0);
 const glob = async ({ cwd, workingDir = cwd, patterns, ignore = [], gitignore = true, }) => {
     const cwdPosix = ensurePosixPath(cwd);

package/dist/util/members.d.ts

@@ -1,4 +1,4 @@
 import { MethodDeclaration, PropertyDeclaration } from 'ts-morph';
 import type { ClassDeclaration, EnumDeclaration } from 'ts-morph';
-export declare const findUnusedClassMembers: (declaration: ClassDeclaration, filePath: string) => (PropertyDeclaration | MethodDeclaration)[];
+export declare const findUnusedClassMembers: (declaration: ClassDeclaration, filePath: string) => (MethodDeclaration | PropertyDeclaration)[];
 export declare const findUnusedEnumMembers: (declaration: EnumDeclaration, filePath: string) => import("ts-morph").EnumMember[];

package/dist/util/modules.d.ts

@@ -1 +1,3 @@
 export declare const getPackageName: (value: string) => string;
+export declare const isDefinitelyTyped: (packageName: string) => boolean;
+export declare const getDefinitelyTypedPackage: (packageName: string) => string;

package/dist/util/modules.js

@@ -8,3 +8,9 @@ export const getPackageName = (value) => {
     }
     return value.startsWith('/') ? value : value.split('/')[0];
 };
+export const isDefinitelyTyped = (packageName) => packageName.startsWith('@types/');
+export const getDefinitelyTypedPackage = (packageName) => {
+    if (isDefinitelyTyped(packageName))
+        return packageName;
+    return '@types/' + packageName.replace('@', '__');
+};

package/dist/workspace-worker.js

@@ -3,7 +3,7 @@ import * as npm from './npm-scripts/index.js';
 import * as plugins from './plugins/index.js';
 import { ROOT_WORKSPACE_NAME, TEST_FILE_PATTERNS } from './util/constants.js';
 import { debugLogFiles, debugLogIssues } from './util/debug.js';
-import { _pureGlob, negate } from './util/glob.js';
+import { _pureGlob, negate, removeProductionSuffix } from './util/glob.js';
 const negatedTestFilePatterns = TEST_FILE_PATTERNS.map(negate);
 export default class WorkspaceWorker {
     name;
@@ -51,7 +51,7 @@ export default class WorkspaceWorker {
     }
     getConfigForPlugin(pluginName) {
         return (this.config[pluginName] ??
-            this.rootWorkspaceConfig[pluginName] ?? { config: [], entryFiles: [], projectFiles: [] });
+            this.rootWorkspaceConfig[pluginName] ?? { config: [], entryFiles: [], projectFiles: [], sampleFiles: [] });
     }
     async init() {
         this.setEnabledPlugins();
@@ -69,7 +69,7 @@ export default class WorkspaceWorker {
     async initReferencedDependencies() {
         const { dependencies, peerDependencies } = await npm.findDependencies(this.rootConfig.ignoreBinaries, this.manifest, this.isRoot, this.dir, this.rootWorkspaceDir);
         const filePath = path.join(this.dir, 'package.json');
-        dependencies.forEach(dependency => this.referencedDependencyIssues.add({ filePath, symbol: dependency }));
+        dependencies.forEach(dependency => this.referencedDependencyIssues.add({ type: 'unlisted', filePath, symbol: dependency }));
         dependencies.forEach(dependency => this.referencedDependencies.add(dependency));
         this.peerDependencies = peerDependencies;
     }
@@ -79,7 +79,7 @@ export default class WorkspaceWorker {
             return [];
         return [entryFiles, TEST_FILE_PATTERNS, this.isRoot ? this.negatedWorkspacePatterns : []]
             .flat()
-            .map(p => p.replace(/!$/, ''));
+            .map(removeProductionSuffix);
     }
     getProjectFilePatterns() {
         const { projectFiles } = this.config;
@@ -87,7 +87,7 @@ export default class WorkspaceWorker {
             return [];
         return [projectFiles, TEST_FILE_PATTERNS, this.isRoot ? this.negatedWorkspacePatterns : []]
             .flat()
-            .map(p => p.replace(/!$/, ''));
+            .map(removeProductionSuffix);
     }
     getPluginEntryFilePatterns(isProduction = false) {
         const patterns = [];
@@ -103,7 +103,7 @@ export default class WorkspaceWorker {
                 }
             }
         }
-        return patterns.flat().map(p => p.replace(/!$/, ''));
+        return patterns.flat().map(removeProductionSuffix);
     }
     getPluginProjectFilePatterns() {
         const patterns = [];
@@ -118,7 +118,7 @@ export default class WorkspaceWorker {
                 patterns.push(projectFilePatterns.length > 0 ? projectFilePatterns : entryFilesPatterns);
             }
         }
-        return patterns.flat().map(p => p.replace(/!$/, ''));
+        return patterns.flat().map(removeProductionSuffix);
     }
     getPluginConfigPatterns() {
         const patterns = [];
@@ -130,7 +130,7 @@ export default class WorkspaceWorker {
                 patterns.push(...pluginConfig.config);
             }
         }
-        return patterns.flat().map(p => p.replace(/!$/, ''));
+        return patterns.flat().map(removeProductionSuffix);
     }
     getProductionEntryFilePatterns() {
         const entryFiles = this.config.entryFiles.filter(p => p.endsWith('!'));
@@ -139,18 +139,18 @@ export default class WorkspaceWorker {
         const negatedEntryFiles = this.config.entryFiles.filter(p => !p.endsWith('!')).map(negate);
         return [entryFiles, negatedEntryFiles, negatedTestFilePatterns, this.isRoot ? this.negatedWorkspacePatterns : []]
             .flat()
-            .map(p => p.replace(/!$/, ''));
+            .map(removeProductionSuffix);
     }
     getProductionProjectFilePatterns() {
         const projectFiles = this.config.projectFiles;
         if (projectFiles.length === 0)
             return this.getProductionEntryFilePatterns();
-        const _projectFiles = this.config.projectFiles.map(p => {
-            if (!p.endsWith('!') && !p.startsWith('!'))
-                return negate(p);
-            return p;
+        const _projectFiles = this.config.projectFiles.map(pattern => {
+            if (!pattern.endsWith('!') && !pattern.startsWith('!'))
+                return negate(pattern);
+            return pattern;
         });
-        const negatedEntryFiles = this.config.entryFiles.filter(p => !p.endsWith('!')).map(negate);
+        const negatedEntryFiles = this.config.entryFiles.filter(pattern => !pattern.endsWith('!')).map(negate);
         const negatedPluginConfigPatterns = this.getPluginConfigPatterns().map(negate);
         const negatedPluginEntryFilePatterns = this.getPluginEntryFilePatterns(true).map(negate);
         const negatedPluginProjectFilePatterns = this.getPluginProjectFilePatterns().map(negate);
@@ -164,7 +164,7 @@ export default class WorkspaceWorker {
             this.isRoot ? this.negatedWorkspacePatterns : [],
         ]
             .flat()
-            .map(p => p.replace(/!$/, ''));
+            .map(removeProductionSuffix);
     }
     getProductionPluginEntryFilePatterns() {
         const patterns = [];
@@ -178,10 +178,9 @@ export default class WorkspaceWorker {
                 }
             }
         }
-        const p = patterns.flat().map(p => p.replace(/!$/, ''));
-        if (p.length === 0)
+        if (patterns.length === 0)
             return [];
-        return [p, negatedTestFilePatterns].flat();
+        return [patterns.flat().map(removeProductionSuffix), negatedTestFilePatterns].flat();
     }
     getConfigurationEntryFilePattern(pluginName) {
         const pluginConfig = this.getConfigForPlugin(pluginName);
@@ -213,14 +212,19 @@ export default class WorkspaceWorker {
         const cwd = this.dir;
         const ignore = this.getWorkspaceIgnorePatterns();
         const configFilePaths = await _pureGlob({ patterns, cwd, ignore });
+        const pluginConfig = this.getConfigForPlugin(pluginName);
         debugLogFiles(1, `Globbed ${pluginName} config file paths`, configFilePaths);
         if (configFilePaths.length === 0)
             return [];
-        const referencedDependencies = (await Promise.all(configFilePaths.map(async (configFilePath) => {
-            const dependencies = await pluginCallback(configFilePath, { cwd, manifest: this.manifest });
-            return dependencies.map(symbol => ({ filePath: configFilePath, symbol }));
+        const referencedDependencyIssues = (await Promise.all(configFilePaths.map(async (configFilePath) => {
+            const dependencies = await pluginCallback(configFilePath, {
+                cwd,
+                manifest: this.manifest,
+                config: pluginConfig,
+            });
+            return dependencies.map(symbol => ({ type: 'unlisted', filePath: configFilePath, symbol }));
         }))).flat();
-        debugLogIssues(1, `Dependencies used by ${pluginName} configuration`, referencedDependencies);
-        return referencedDependencies;
+        debugLogIssues(1, `Dependencies used by ${pluginName} configuration`, referencedDependencyIssues);
+        return referencedDependencyIssues;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "1.0.0-alpha.0",
+  "version": "1.0.0-alpha.2",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript project",
   "keywords": [
     "find",