knip 5.44.1 → 5.44.3

package/dist/ConfigurationChief.js

@@ -1,8 +1,7 @@
 import picomatch from 'picomatch';
-import { ConfigurationValidator } from './ConfigurationValidator.js';
 import { partitionCompilers } from './compilers/index.js';
 import { DEFAULT_EXTENSIONS, KNIP_CONFIG_LOCATIONS, ROOT_WORKSPACE_NAME } from './constants.js';
-import { defaultRules } from './issues/initializers.js';
+import { knipConfigurationSchema } from './schema/configuration.js';
 import { pluginNames } from './types/PluginNames.js';
 import { arrayify, compact } from './util/array.js';
 import parsedArgValues from './util/cli-arguments.js';
@@ -11,6 +10,7 @@ import { ConfigurationError } from './util/errors.js';
 import { findFile, isDirectory, isFile, loadJSON } from './util/fs.js';
 import { getIncludedIssueTypes } from './util/get-included-issue-types.js';
 import { _dirGlob } from './util/glob.js';
+import { defaultRules } from './util/issue-initializers.js';
 import { _load } from './util/loader.js';
 import mapWorkspaces from './util/map-workspaces.js';
 import { getKeysByValue } from './util/object.js';
@@ -96,7 +96,7 @@ export class ConfigurationChief {
         this.rawConfig = this.resolvedConfigFilePath
             ? await this.loadResolvedConfigurationFile(this.resolvedConfigFilePath)
             : manifest.knip;
-        const parsedConfig = this.rawConfig ? ConfigurationValidator.parse(partitionCompilers(this.rawConfig)) : {};
+        const parsedConfig = this.rawConfig ? knipConfigurationSchema.parse(partitionCompilers(this.rawConfig)) : {};
         this.config = this.normalize(parsedConfig);
         await this.setWorkspaces();
     }
@@ -205,7 +205,7 @@ export class ConfigurationChief {
     }
     getIncludedWorkspaces() {
         if (this.workspace) {
-            const dir = resolve(this.workspace);
+            const dir = resolve(this.cwd, this.workspace);
             if (!isDirectory(dir))
                 throw new ConfigurationError('Workspace is not a directory');
             if (!isFile(join(dir, 'package.json')))

package/dist/IssueCollector.js

@@ -1,6 +1,6 @@
 import picomatch from 'picomatch';
-import { initCounters, initIssues } from './issues/initializers.js';
 import { timerify } from './util/Performance.js';
+import { initCounters, initIssues } from './util/issue-initializers.js';
 import { relative } from './util/path.js';
 const hasConfigurationHint = (hints, hint) => Array.from(hints).some(item => item.identifier === hint.identifier && item.type === hint.type && item.workspaceName === hint.workspaceName);
 const isMatch = timerify(picomatch.isMatch, 'isMatch');

package/dist/ProjectPrincipal.d.ts

@@ -2,7 +2,7 @@ import ts from 'typescript';
 import { CacheConsultant } from './CacheConsultant.js';
 import type { AsyncCompilers, SyncCompilers } from './compilers/types.js';
 import type { GetImportsAndExportsOptions } from './types/config.js';
-import type { DependencyGraph, Export, ExportMember, FileNode } from './types/dependency-graph.js';
+import type { Export, ExportMember, FileNode, ModuleGraph } from './types/module-graph.js';
 import type { PrincipalOptions } from './types/project.js';
 import type { SourceFileManager } from './typescript/SourceFileManager.js';
 import type { ResolveModuleNames } from './typescript/resolve-module-names.js';
@@ -50,9 +50,9 @@ export declare class ProjectPrincipal {
     getUsedResolvedFiles(): string[];
     private getProgramSourceFiles;
     getUnreferencedFiles(): string[];
-    analyzeSourceFile(filePath: string, options: Omit<GetImportsAndExportsOptions, 'skipExports'>, isGitIgnored: (filePath: string) => boolean, isPackageNameInternalWorkspace: (packageName: string) => boolean, getPrincipalByFilePath: (filePath: string) => undefined | ProjectPrincipal): FileNode;
+    analyzeSourceFile(filePath: string, options: Omit<GetImportsAndExportsOptions, 'skipExports'>, isGitIgnored: (filePath: string) => boolean, isInternalWorkspace: (packageName: string) => boolean, getPrincipalByFilePath: (filePath: string) => undefined | ProjectPrincipal): FileNode;
     invalidateFile(filePath: string): void;
     findUnusedMembers(filePath: string, members: ExportMember[]): ExportMember[];
     hasExternalReferences(filePath: string, exportedItem: Export): boolean;
-    reconcileCache(graph: DependencyGraph): void;
+    reconcileCache(graph: ModuleGraph): void;
 }

package/dist/ProjectPrincipal.js

@@ -143,7 +143,7 @@ export class ProjectPrincipal {
         const sourceFiles = this.getProgramSourceFiles();
         return Array.from(this.projectPaths).filter(filePath => !sourceFiles.has(filePath));
     }
-    analyzeSourceFile(filePath, options, isGitIgnored, isPackageNameInternalWorkspace, getPrincipalByFilePath) {
+    analyzeSourceFile(filePath, options, isGitIgnored, isInternalWorkspace, getPrincipalByFilePath) {
         const fd = this.cache.getFileDescriptor(filePath);
         if (!fd.changed && fd.meta?.data)
             return fd.meta.data;
@@ -160,7 +160,7 @@ export class ProjectPrincipal {
         const unresolvedImports = new Set();
         for (const [specifier, specifierFilePath] of specifiers) {
             const packageName = getPackageNameFromModuleSpecifier(specifier);
-            if (packageName && isPackageNameInternalWorkspace(packageName)) {
+            if (packageName && isInternalWorkspace(packageName)) {
                 external.add(packageName);
                 const principal = getPrincipalByFilePath(specifierFilePath);
                 if (principal && !isGitIgnored(specifierFilePath))

package/dist/WorkspaceWorker.js

@@ -285,7 +285,11 @@ export class WorkspaceWorker {
         do {
             for (const [pluginName, dependencies] of configFiles.entries()) {
                 configFiles.delete(pluginName);
-                await runPlugin(pluginName, Array.from(dependencies));
+                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);
         debugLogArray(name, 'Plugin dependencies', () => compact(inputs.map(toDebugString)));

package/dist/graph/analyze.d.ts

@@ -0,0 +1,30 @@
+import type { ConfigurationChief } from '../ConfigurationChief.js';
+import type { ConsoleStreamer } from '../ConsoleStreamer.js';
+import type { DependencyDeputy } from '../DependencyDeputy.js';
+import type { IssueCollector } from '../IssueCollector.js';
+import type { IssueFixer } from '../IssueFixer.js';
+import type { PrincipalFactory } from '../PrincipalFactory.js';
+import type { Tags } from '../types/cli.js';
+import type { Report } from '../types/issues.js';
+import type { ModuleGraph } from '../types/module-graph.js';
+interface AnalyzeOptions {
+    analyzedFiles: Set<string>;
+    chief: ConfigurationChief;
+    collector: IssueCollector;
+    deputy: DependencyDeputy;
+    entryPaths: Set<string>;
+    factory: PrincipalFactory;
+    fixer: IssueFixer;
+    graph: ModuleGraph;
+    isFix: boolean;
+    isHideConfigHints: boolean;
+    isIncludeLibs: boolean;
+    isProduction: boolean;
+    report: Report;
+    streamer: ConsoleStreamer;
+    tags: Tags;
+    unreferencedFiles: Set<string>;
+    workspace?: string;
+}
+export declare const analyze: (options: AnalyzeOptions) => Promise<() => Promise<void>>;
+export {};

package/dist/graph/analyze.js

@@ -0,0 +1,232 @@
+import { getType, hasStrictlyEnumReferences, hasStrictlyNsReferences } from '../util/has-strictly-ns-references.js';
+import { getIsIdentifierReferencedHandler } from '../util/is-identifier-referenced.js';
+import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
+import { findMatch } from '../util/regex.js';
+import { getShouldIgnoreHandler, getShouldIgnoreTagHandler } from '../util/tag.js';
+import { createAndPrintTrace, printTrace } from '../util/trace.js';
+export const analyze = async (options) => {
+    const { analyzedFiles, chief, collector, deputy, entryPaths, factory, fixer, graph, isFix, isHideConfigHints, isIncludeLibs, isProduction, report, streamer, tags, unreferencedFiles, workspace, } = options;
+    const isReportDependencies = report.dependencies || report.unlisted || report.unresolved;
+    const isReportValues = report.exports || report.nsExports || report.classMembers;
+    const isReportTypes = report.types || report.nsTypes || report.enumMembers;
+    const isReportClassMembers = report.classMembers;
+    const isSkipLibs = !(isIncludeLibs || isReportClassMembers);
+    const isShowConfigHints = !workspace && !isProduction && !isHideConfigHints;
+    const shouldIgnore = getShouldIgnoreHandler(isProduction);
+    const shouldIgnoreTags = getShouldIgnoreTagHandler(tags);
+    const isIdentifierReferenced = getIsIdentifierReferencedHandler(graph, entryPaths);
+    const ignoreExportsUsedInFile = chief.config.ignoreExportsUsedInFile;
+    const isExportedItemReferenced = (exportedItem) => exportedItem.refs[1] ||
+        (exportedItem.refs[0] > 0 &&
+            (typeof ignoreExportsUsedInFile === 'object'
+                ? exportedItem.type !== 'unknown' && !!ignoreExportsUsedInFile[exportedItem.type]
+                : ignoreExportsUsedInFile));
+    const analyzeGraph = async () => {
+        if (isReportValues || isReportTypes) {
+            streamer.cast('Connecting the dots...');
+            for (const [filePath, file] of graph.entries()) {
+                const exportItems = file.exports;
+                if (!exportItems || exportItems.size === 0)
+                    continue;
+                const workspace = chief.findWorkspaceByFilePath(filePath);
+                if (workspace) {
+                    const { isIncludeEntryExports } = workspace.config;
+                    const principal = factory.getPrincipalByPackageName(workspace.pkgName);
+                    const isEntry = entryPaths.has(filePath);
+                    if (!isIncludeEntryExports && isEntry) {
+                        createAndPrintTrace(filePath, { isEntry });
+                        continue;
+                    }
+                    const importsForExport = file.imported;
+                    for (const [identifier, exportedItem] of exportItems.entries()) {
+                        if (!isFix && exportedItem.isReExport)
+                            continue;
+                        if (shouldIgnore(exportedItem.jsDocTags))
+                            continue;
+                        const isIgnored = shouldIgnoreTags(exportedItem.jsDocTags);
+                        if (importsForExport) {
+                            const { isReferenced, reExportingEntryFile, traceNode } = isIdentifierReferenced(filePath, identifier, isIncludeEntryExports);
+                            if ((isReferenced || exportedItem.refs[1]) && isIgnored) {
+                                for (const tagName of exportedItem.jsDocTags) {
+                                    if (tags[1].includes(tagName.replace(/^\@/, ''))) {
+                                        collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
+                                    }
+                                }
+                            }
+                            if (isIgnored)
+                                continue;
+                            if (reExportingEntryFile) {
+                                if (!isIncludeEntryExports) {
+                                    createAndPrintTrace(filePath, { identifier, isEntry, hasRef: isReferenced });
+                                    continue;
+                                }
+                                const reExportedItem = graph.get(reExportingEntryFile)?.exports.get(identifier);
+                                if (reExportedItem && shouldIgnore(reExportedItem.jsDocTags))
+                                    continue;
+                            }
+                            if (traceNode)
+                                printTrace(traceNode, filePath, identifier);
+                            if (isReferenced) {
+                                if (report.enumMembers && exportedItem.type === 'enum') {
+                                    if (!report.nsTypes && importsForExport.refs.has(identifier))
+                                        continue;
+                                    if (hasStrictlyEnumReferences(importsForExport, identifier))
+                                        continue;
+                                    for (const member of exportedItem.members) {
+                                        if (findMatch(workspace.ignoreMembers, member.identifier))
+                                            continue;
+                                        if (shouldIgnore(member.jsDocTags))
+                                            continue;
+                                        if (member.refs[0] === 0) {
+                                            const id = `${identifier}.${member.identifier}`;
+                                            const { isReferenced } = isIdentifierReferenced(filePath, id, true);
+                                            const isIgnored = shouldIgnoreTags(member.jsDocTags);
+                                            if (!isReferenced) {
+                                                if (isIgnored)
+                                                    continue;
+                                                const isIssueAdded = collector.addIssue({
+                                                    type: 'enumMembers',
+                                                    filePath,
+                                                    workspace: workspace.name,
+                                                    symbol: member.identifier,
+                                                    parentSymbol: identifier,
+                                                    pos: member.pos,
+                                                    line: member.line,
+                                                    col: member.col,
+                                                });
+                                                if (isFix && isIssueAdded && member.fix)
+                                                    fixer.addUnusedTypeNode(filePath, [member.fix]);
+                                            }
+                                            else if (isIgnored) {
+                                                for (const tagName of exportedItem.jsDocTags) {
+                                                    if (tags[1].includes(tagName.replace(/^\@/, ''))) {
+                                                        collector.addTagHint({ type: 'tag', filePath, identifier: id, tagName });
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                if (principal && isReportClassMembers && exportedItem.type === 'class') {
+                                    const members = exportedItem.members.filter(member => !(findMatch(workspace.ignoreMembers, member.identifier) || shouldIgnore(member.jsDocTags)));
+                                    for (const member of principal.findUnusedMembers(filePath, members)) {
+                                        if (shouldIgnoreTags(member.jsDocTags)) {
+                                            const identifier = `${exportedItem.identifier}.${member.identifier}`;
+                                            for (const tagName of exportedItem.jsDocTags) {
+                                                if (tags[1].includes(tagName.replace(/^\@/, ''))) {
+                                                    collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
+                                                }
+                                            }
+                                            continue;
+                                        }
+                                        const isIssueAdded = collector.addIssue({
+                                            type: 'classMembers',
+                                            filePath,
+                                            workspace: workspace.name,
+                                            symbol: member.identifier,
+                                            parentSymbol: exportedItem.identifier,
+                                            pos: member.pos,
+                                            line: member.line,
+                                            col: member.col,
+                                        });
+                                        if (isFix && isIssueAdded && member.fix)
+                                            fixer.addUnusedTypeNode(filePath, [member.fix]);
+                                    }
+                                }
+                                continue;
+                            }
+                        }
+                        const [hasStrictlyNsRefs, namespace] = hasStrictlyNsReferences(graph, importsForExport, identifier);
+                        const isType = ['enum', 'type', 'interface'].includes(exportedItem.type);
+                        if (hasStrictlyNsRefs && ((!report.nsTypes && isType) || !(report.nsExports || isType)))
+                            continue;
+                        if (!isExportedItemReferenced(exportedItem)) {
+                            if (isIgnored)
+                                continue;
+                            if (!isSkipLibs && principal?.hasExternalReferences(filePath, exportedItem))
+                                continue;
+                            const type = getType(hasStrictlyNsRefs, isType);
+                            const isIssueAdded = collector.addIssue({
+                                type,
+                                filePath,
+                                workspace: workspace.name,
+                                symbol: identifier,
+                                symbolType: exportedItem.type,
+                                parentSymbol: namespace,
+                                pos: exportedItem.pos,
+                                line: exportedItem.line,
+                                col: exportedItem.col,
+                            });
+                            if (isFix && isIssueAdded) {
+                                if (isType)
+                                    fixer.addUnusedTypeNode(filePath, exportedItem.fixes);
+                                else
+                                    fixer.addUnusedExportNode(filePath, exportedItem.fixes);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        for (const [filePath, file] of graph.entries()) {
+            const ws = chief.findWorkspaceByFilePath(filePath);
+            if (ws) {
+                if (file.duplicates) {
+                    for (const symbols of file.duplicates) {
+                        if (symbols.length > 1) {
+                            const symbol = symbols.map(s => s.symbol).join('|');
+                            collector.addIssue({ type: 'duplicates', filePath, workspace: ws.name, symbol, symbols });
+                        }
+                    }
+                }
+                if (file.imports?.external) {
+                    for (const specifier of file.imports.external) {
+                        const packageName = getPackageNameFromModuleSpecifier(specifier);
+                        const isHandled = packageName && deputy.maybeAddReferencedExternalDependency(ws, packageName);
+                        if (!isHandled)
+                            collector.addIssue({
+                                type: 'unlisted',
+                                filePath,
+                                workspace: ws.name,
+                                symbol: packageName ?? specifier,
+                                specifier,
+                            });
+                    }
+                }
+                if (file.imports?.unresolved) {
+                    for (const unresolvedImport of file.imports.unresolved) {
+                        const { specifier, pos, line, col } = unresolvedImport;
+                        collector.addIssue({ type: 'unresolved', filePath, workspace: ws.name, symbol: specifier, pos, line, col });
+                    }
+                }
+            }
+        }
+        const unusedFiles = [...unreferencedFiles].filter(filePath => !analyzedFiles.has(filePath));
+        collector.addFilesIssues(unusedFiles);
+        collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
+        if (isReportDependencies) {
+            const { dependencyIssues, devDependencyIssues, optionalPeerDependencyIssues } = deputy.settleDependencyIssues();
+            for (const issue of dependencyIssues)
+                collector.addIssue(issue);
+            if (!isProduction)
+                for (const issue of devDependencyIssues)
+                    collector.addIssue(issue);
+            for (const issue of optionalPeerDependencyIssues)
+                collector.addIssue(issue);
+            deputy.removeIgnoredIssues(collector.getIssues());
+            if (isShowConfigHints) {
+                const configurationHints = deputy.getConfigurationHints();
+                for (const hint of configurationHints)
+                    collector.addConfigurationHint(hint);
+            }
+        }
+        if (isShowConfigHints) {
+            const unusedIgnoredWorkspaces = chief.getUnusedIgnoredWorkspaces();
+            for (const identifier of unusedIgnoredWorkspaces) {
+                collector.addConfigurationHint({ type: 'ignoreWorkspaces', identifier });
+            }
+        }
+    };
+    await analyzeGraph();
+    return analyzeGraph;
+};

package/dist/graph/build.d.ts

@@ -0,0 +1,40 @@
+import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
+import type { ConsoleStreamer } from '../ConsoleStreamer.js';
+import type { DependencyDeputy } from '../DependencyDeputy.js';
+import type { IssueCollector } from '../IssueCollector.js';
+import type { PrincipalFactory } from '../PrincipalFactory.js';
+import type { ProjectPrincipal } from '../ProjectPrincipal.js';
+import type { Tags } from '../types/cli.js';
+import type { Report } from '../types/issues.js';
+import type { ModuleGraph } from '../types/module-graph.js';
+interface BuildOptions {
+    cacheLocation: string;
+    chief: ConfigurationChief;
+    collector: IssueCollector;
+    cwd: string;
+    deputy: DependencyDeputy;
+    factory: PrincipalFactory;
+    gitignore: boolean;
+    isCache: boolean;
+    isFixExports: boolean;
+    isFixTypes: boolean;
+    isGitIgnored: (path: string) => boolean;
+    isIsolateWorkspaces: boolean;
+    isProduction: boolean;
+    isSkipLibs: boolean;
+    isStrict: boolean;
+    isWatch: boolean;
+    report: Report;
+    streamer: ConsoleStreamer;
+    tags: Tags;
+    tsConfigFile?: string;
+    workspaces: Workspace[];
+}
+export declare function build({ cacheLocation, chief, collector, cwd, deputy, factory, gitignore, isCache, isFixExports, isFixTypes, isGitIgnored, isIsolateWorkspaces, isProduction, isSkipLibs, isStrict, isWatch, report, streamer, tags, tsConfigFile, workspaces, }: BuildOptions): Promise<{
+    graph: ModuleGraph;
+    entryPaths: Set<string>;
+    analyzedFiles: Set<string>;
+    unreferencedFiles: Set<string>;
+    analyzeSourceFile: (filePath: string, principal: ProjectPrincipal) => void;
+}>;
+export {};