knip 3.6.1 → 3.7.1

package/dist/ConfigurationChief.js

@@ -218,7 +218,9 @@ export class ConfigurationChief {
             !micromatch.isMatch(name, this.ignoredWorkspacePatterns)));
     }
     getAvailableWorkspaceNames() {
-        return [ROOT_WORKSPACE_NAME, ...this.manifestWorkspaces.keys(), ...this.additionalWorkspaceNames].filter(name => !micromatch.isMatch(name, this.ignoredWorkspacePatterns));
+        return [
+            ...new Set([ROOT_WORKSPACE_NAME, ...this.manifestWorkspaces.keys(), ...this.additionalWorkspaceNames]),
+        ].filter(name => !micromatch.isMatch(name, this.ignoredWorkspacePatterns));
     }
     getAvailableWorkspaceManifests(availableWorkspaceDirs) {
         return availableWorkspaceDirs.map(dir => {

package/dist/IssueFixer.d.ts

@@ -0,0 +1,21 @@
+import type { ExportPos } from './types/exports.js';
+import type { Issues } from './types/issues.js';
+export declare class IssueFixer {
+    isEnabled: boolean;
+    cwd: string;
+    isFixDependencies: boolean;
+    isFixUnusedTypes: boolean;
+    isFixUnusedExports: boolean;
+    unusedTypeNodes: Map<string, Set<[number, number]>>;
+    unusedExportNodes: Map<string, Set<[number, number]>>;
+    constructor({ isEnabled, cwd, fixTypes }: {
+        isEnabled: boolean;
+        cwd: string;
+        fixTypes: string[];
+    });
+    addUnusedTypeNode(filePath: string, fix: ExportPos): void;
+    addUnusedExportNode(filePath: string, fix: ExportPos): void;
+    fixIssues(issues: Issues): Promise<void>;
+    private removeUnusedExportKeywords;
+    private removeUnusedDependencies;
+}

package/dist/IssueFixer.js

@@ -0,0 +1,75 @@
+import { readFile, writeFile } from 'fs/promises';
+import NPMCliPackageJson from '@npmcli/package-json';
+import { dirname, join } from './util/path.js';
+export class IssueFixer {
+    isEnabled = false;
+    cwd = process.cwd();
+    isFixDependencies = true;
+    isFixUnusedTypes = true;
+    isFixUnusedExports = true;
+    unusedTypeNodes = new Map();
+    unusedExportNodes = new Map();
+    constructor({ isEnabled, cwd, fixTypes = [] }) {
+        this.isEnabled = isEnabled;
+        this.cwd = cwd;
+        this.isFixDependencies = fixTypes.length === 0 || fixTypes.includes('dependencies');
+        this.isFixUnusedTypes = fixTypes.length === 0 || fixTypes.includes('types');
+        this.isFixUnusedExports = fixTypes.length === 0 || fixTypes.includes('exports');
+    }
+    addUnusedTypeNode(filePath, fix) {
+        if (fix.length === 0)
+            return;
+        if (this.unusedTypeNodes.has(filePath))
+            this.unusedTypeNodes.get(filePath).add(fix);
+        else
+            this.unusedTypeNodes.set(filePath, new Set([fix]));
+    }
+    addUnusedExportNode(filePath, fix) {
+        if (fix.length === 0)
+            return;
+        if (this.unusedExportNodes.has(filePath))
+            this.unusedExportNodes.get(filePath).add(fix);
+        else
+            this.unusedExportNodes.set(filePath, new Set([fix]));
+    }
+    async fixIssues(issues) {
+        await this.removeUnusedExportKeywords();
+        await this.removeUnusedDependencies(issues);
+    }
+    async removeUnusedExportKeywords() {
+        const filePaths = new Set([...this.unusedTypeNodes.keys(), ...this.unusedExportNodes.keys()]);
+        for (const filePath of filePaths) {
+            const exportPositions = [
+                ...(this.isFixUnusedTypes ? this.unusedTypeNodes.get(filePath) ?? [] : []),
+                ...(this.isFixUnusedExports ? this.unusedExportNodes.get(filePath) ?? [] : []),
+            ].sort((a, b) => b[0] - a[0]);
+            if (exportPositions.length > 0) {
+                const text = await readFile(filePath, 'utf-8');
+                const sourceFileText = exportPositions.reduce((text, [start, end]) => text.substring(0, start) + text.substring(end), text);
+                await writeFile(filePath, sourceFileText);
+            }
+        }
+    }
+    async removeUnusedDependencies(issues) {
+        if (!this.isFixDependencies)
+            return;
+        const filePaths = new Set([...Object.keys(issues.dependencies), ...Object.keys(issues.devDependencies)]);
+        for (const filePath of filePaths) {
+            const manifest = await NPMCliPackageJson.load(dirname(join(this.cwd, filePath)));
+            const pkg = manifest.content;
+            if (filePath in issues.dependencies) {
+                Object.keys(issues.dependencies[filePath]).forEach(dependency => {
+                    if (pkg.dependencies)
+                        delete pkg.dependencies[dependency];
+                });
+            }
+            if (filePath in issues.devDependencies) {
+                Object.keys(issues.devDependencies[filePath]).forEach(dependency => {
+                    if (pkg.devDependencies)
+                        delete pkg.devDependencies[dependency];
+                });
+            }
+            await manifest.save();
+        }
+    }
+}

package/dist/ProjectPrincipal.d.ts

@@ -38,8 +38,10 @@ export declare class ProjectPrincipal {
     getUsedResolvedFiles(): string[];
     private getProgramSourceFiles;
     getUnreferencedFiles(): string[];
-    analyzeSourceFile(filePath: string, { skipTypeOnly }: {
+    analyzeSourceFile(filePath: string, { skipTypeOnly, isFixExports, isFixTypes }: {
         skipTypeOnly: boolean;
+        isFixExports: boolean;
+        isFixTypes: boolean;
     }): {
         imports: {
             internal: import("./types/imports.js").Imports;

package/dist/ProjectPrincipal.js

@@ -113,7 +113,7 @@ export class ProjectPrincipal {
         const sourceFiles = this.getProgramSourceFiles();
         return Array.from(this.projectPaths).filter(filePath => !sourceFiles.has(filePath));
     }
-    analyzeSourceFile(filePath, { skipTypeOnly }) {
+    analyzeSourceFile(filePath, { skipTypeOnly, isFixExports, isFixTypes }) {
         const sourceFile = this.backend.fileManager.getSourceFile(filePath);
         if (!sourceFile)
             throw new Error(`Unable to find ${filePath}`);
@@ -124,6 +124,8 @@ export class ProjectPrincipal {
         const { imports, exports, scripts } = _getImportsAndExports(sourceFile, getResolvedModule, {
             skipTypeOnly,
             skipExports,
+            isFixExports,
+            isFixTypes,
         });
         const { internal, unresolved, external } = imports;
         const unresolvedImports = new Set();

package/dist/cli.js

@@ -7,7 +7,7 @@ import { Performance } from './util/Performance.js';
 import { runPreprocessors, runReporters } from './util/reporter.js';
 import { version } from './version.js';
 import { main } from './index.js';
-const { debug: isDebug = false, help: isHelp, 'max-issues': maxIssues = '0', 'no-config-hints': noConfigHints = false, 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = false, 'include-entry-exports': isIncludeEntryExports = false, 'isolate-workspaces': isIsolateWorkspaces = false, performance: isObservePerf = false, production: isProduction = false, 'reporter-options': reporterOptions = '', 'preprocessor-options': preprocessorOptions = '', strict: isStrict = false, tsConfig, version: isVersion, } = parsedArgValues;
+const { debug: isDebug = false, help: isHelp, 'max-issues': maxIssues = '0', 'no-config-hints': noConfigHints = false, 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = false, 'include-entry-exports': isIncludeEntryExports = false, 'isolate-workspaces': isIsolateWorkspaces = false, performance: isObservePerf = false, production: isProduction = false, 'reporter-options': reporterOptions = '', 'preprocessor-options': preprocessorOptions = '', strict: isStrict = false, fix: isFix = false, 'fix-type': fixTypes = [], tsConfig, version: isVersion, } = parsedArgValues;
 if (isHelp) {
     console.log(helpText);
     process.exit(0);
@@ -29,6 +29,8 @@ const run = async () => {
             isShowProgress,
             isIncludeEntryExports,
             isIsolateWorkspaces,
+            isFix,
+            fixTypes: fixTypes.flatMap(type => type.split(',')),
         });
         const initialData = {
             report,

package/dist/index.js

@@ -5,6 +5,7 @@ import { ConfigurationChief } from './ConfigurationChief.js';
 import { ConsoleStreamer } from './ConsoleStreamer.js';
 import { DependencyDeputy } from './DependencyDeputy.js';
 import { IssueCollector } from './IssueCollector.js';
+import { IssueFixer } from './IssueFixer.js';
 import { PrincipalFactory } from './PrincipalFactory.js';
 import { ProjectPrincipal } from './ProjectPrincipal.js';
 import { debugLogObject, debugLogArray, debugLog } from './util/debug.js';
@@ -16,7 +17,7 @@ import { _resolveSpecifier } from './util/require.js';
 import { loadTSConfig } from './util/tsconfig-loader.js';
 import { WorkspaceWorker } from './WorkspaceWorker.js';
 export const main = async (unresolvedConfiguration) => {
-    const { cwd, tsConfigFile, gitignore, isStrict, isProduction, isShowProgress, isIncludeEntryExports, isIsolateWorkspaces, } = unresolvedConfiguration;
+    const { cwd, tsConfigFile, gitignore, isStrict, isProduction, isShowProgress, isIncludeEntryExports, isIsolateWorkspaces, isFix, fixTypes, } = unresolvedConfiguration;
     debugLogObject('*', 'Unresolved configuration (from CLI arguments)', unresolvedConfiguration);
     const chief = new ConfigurationChief({ cwd, isProduction, isStrict, isIncludeEntryExports });
     const deputy = new DependencyDeputy({ isProduction, isStrict });
@@ -30,6 +31,7 @@ export const main = async (unresolvedConfiguration) => {
     const report = chief.getIssueTypesToReport();
     const rules = chief.getRules();
     const filters = chief.getFilters();
+    const fixer = new IssueFixer({ isEnabled: isFix || fixTypes.length > 0, cwd, fixTypes });
     const isReportDependencies = report.dependencies || report.unlisted || report.unresolved;
     const isReportValues = report.exports || report.nsExports || report.classMembers;
     const isReportTypes = report.types || report.nsTypes || report.enumMembers;
@@ -190,7 +192,11 @@ export const main = async (unresolvedConfiguration) => {
         const analyzeSourceFile = (filePath, _principal = principal) => {
             const workspace = chief.findWorkspaceByFilePath(filePath);
             if (workspace) {
-                const { imports, exports, scripts } = _principal.analyzeSourceFile(filePath, { skipTypeOnly: isStrict });
+                const { imports, exports, scripts } = _principal.analyzeSourceFile(filePath, {
+                    skipTypeOnly: isStrict,
+                    isFixExports: fixer.isFixUnusedExports,
+                    isFixTypes: fixer.isFixUnusedTypes,
+                });
                 const { internal, external, unresolved } = imports;
                 const { exported, duplicate } = exports;
                 if (exported.size > 0)
@@ -351,6 +357,10 @@ export const main = async (unresolvedConfiguration) => {
                             symbolType: exportedItem.type,
                             ...principal.getPos(exportedItem.node, exportedItem.pos),
                         });
+                        if (isType)
+                            fixer.addUnusedTypeNode(filePath, exportedItem.fix);
+                        else
+                            fixer.addUnusedExportNode(filePath, exportedItem.fix);
                     }
                 }
             }
@@ -374,6 +384,9 @@ export const main = async (unresolvedConfiguration) => {
     const unusedIgnoredWorkspaces = chief.getUnusedIgnoredWorkspaces();
     unusedIgnoredWorkspaces.forEach(identifier => collector.addConfigurationHint({ type: 'ignoreWorkspaces', identifier }));
     const { issues, counters, configurationHints } = collector.getIssues();
+    if (isFix) {
+        await fixer.fixIssues(issues);
+    }
     streamer.clear();
     return { report, issues, counters, rules, configurationHints };
 };

package/dist/plugins/eslint/helpers.js

@@ -1,6 +1,6 @@
 import { compact } from '../../util/array.js';
-import { getPackageNameFromModuleSpecifier } from '../../util/modules.js';
-import { basename, isInternal, dirname, toAbsolute } from '../../util/path.js';
+import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from '../../util/modules.js';
+import { basename, isInternal, dirname, toAbsolute, isAbsolute } from '../../util/path.js';
 import { load } from '../../util/plugin.js';
 import { _resolve } from '../../util/require.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
@@ -72,10 +72,20 @@ const getDependenciesFromSettings = (settings = {}) => {
         if (settingKey === 'import/resolver') {
             return (typeof settings === 'string' ? [settings] : Object.keys(settings))
                 .filter(key => key !== 'node')
-                .map(key => `eslint-import-resolver-${key}`);
+                .map(key => {
+                if (isInternal(key))
+                    return key;
+                if (isAbsolute(key))
+                    return getPackageNameFromFilePath(key);
+                return `eslint-import-resolver-${key}`;
+            });
         }
         if (settingKey === 'import/parsers') {
-            return typeof settings === 'string' ? [settings] : Object.keys(settings);
+            return (typeof settings === 'string' ? [settings] : Object.keys(settings)).map(key => {
+                if (isAbsolute(key))
+                    return getPackageNameFromFilePath(key);
+                return key;
+            });
         }
     });
 };

package/dist/types/cli.d.ts

@@ -7,4 +7,6 @@ export interface CommandLineOptions {
     isShowProgress: boolean;
     isIncludeEntryExports: boolean;
     isIsolateWorkspaces: boolean;
+    isFix: boolean;
+    fixTypes: string[];
 }

package/dist/types/exports.d.ts

@@ -2,6 +2,7 @@ import ts from 'typescript';
 import type { SymbolType } from './issues.js';
 type FilePath = string;
 type Identifier = string;
+export type ExportPos = [number, number] | [];
 export type ExportItem = {
     node: ts.Node;
     pos: number;
@@ -9,12 +10,14 @@ export type ExportItem = {
     type: SymbolType;
     members?: ExportItemMember[];
     jsDocTags?: Set<string>;
+    fix: ExportPos;
 };
 export type ExportItemMember = {
     node: ts.Node;
     identifier: Identifier;
     pos: number;
     type: SymbolType;
+    fix: ExportPos;
 };
 export type ExportItems = Map<string, Required<ExportItem>>;
 export type Exports = Map<FilePath, ExportItems>;

package/dist/typescript/getImportsAndExports.d.ts

@@ -1,11 +1,13 @@
 import ts from 'typescript';
 import type { BoundSourceFile, GetResolvedModule } from './SourceFile.js';
-import type { ExportItems as Exports, ExportItem } from '../types/exports.js';
+import type { ExportItems as Exports, ExportItem, ExportPos } from '../types/exports.js';
 import type { Imports, UnresolvedImport } from '../types/imports.js';
 import type { IssueSymbol } from '../types/issues.js';
 export type GetImportsAndExportsOptions = {
     skipTypeOnly: boolean;
     skipExports: boolean;
+    isFixExports: boolean;
+    isFixTypes: boolean;
 };
 export type AddImportOptions = {
     specifier: string;
@@ -16,6 +18,7 @@ export type AddImportOptions = {
 };
 export type AddExportOptions = ExportItem & {
     identifier: string;
+    fix: ExportPos;
 };
 export declare const _getImportsAndExports: (sourceFile: BoundSourceFile, getResolvedModule: GetResolvedModule, options: GetImportsAndExportsOptions) => {
     imports: {

package/dist/typescript/getImportsAndExports.js

@@ -95,7 +95,7 @@ const getImportsAndExports = (sourceFile, getResolvedModule, options) => {
             }
         }
     };
-    const addExport = ({ node, identifier, type, pos, posDecl, members = [] }) => {
+    const addExport = ({ node, identifier, type, pos, posDecl, members = [], fix }) => {
         if (options.skipExports)
             return;
         const jsDocTags = getJSDocTags(node);
@@ -106,7 +106,7 @@ const getImportsAndExports = (sourceFile, getResolvedModule, options) => {
             exports.set(identifier, { ...item, members: crew, jsDocTags: tags });
         }
         else {
-            exports.set(identifier, { node, type, members, jsDocTags, pos, posDecl: posDecl ?? pos });
+            exports.set(identifier, { node, type, members, jsDocTags, pos, posDecl: posDecl ?? pos, fix });
         }
         if (!jsDocTags.has('@alias')) {
             if (ts.isExportAssignment(node))

package/dist/typescript/visitors/exports/exportAssignment.js

@@ -1,9 +1,10 @@
 import ts from 'typescript';
 import { SymbolType } from '../../../types/issues.js';
 import { exportVisitor as visit } from '../index.js';
-export default visit(() => true, node => {
+export default visit(() => true, (node, { isFixExports }) => {
     if (ts.isExportAssignment(node)) {
         const pos = node.getChildAt(1).getStart();
-        return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos };
+        const fix = isFixExports ? [node.getStart(), node.getEnd() + 1] : [];
+        return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos, fix };
     }
 });

package/dist/typescript/visitors/exports/exportDeclaration.js

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { SymbolType } from '../../../types/issues.js';
 import { exportVisitor as visit } from '../index.js';
-export default visit(() => true, node => {
+export default visit(() => true, (node, { isFixExports, isFixTypes }) => {
     if (ts.isExportDeclaration(node)) {
         if (node.exportClause && ts.isNamedExports(node.exportClause)) {
             const type = node.isTypeOnly ? SymbolType.TYPE : SymbolType.UNKNOWN;
@@ -13,13 +13,8 @@ export default visit(() => true, node => {
                 const pos = element.name.pos;
                 const name = ts.getNameOfDeclaration(declaration);
                 const posDecl = name?.pos ?? declaration?.pos ?? pos;
-                return {
-                    node: element,
-                    identifier,
-                    type,
-                    pos,
-                    posDecl,
-                };
+                const fix = isFixExports || isFixTypes ? [element.getStart(), element.getEnd()] : [];
+                return { node: element, identifier, type, pos, posDecl, fix };
             });
         }
     }

package/dist/typescript/visitors/exports/exportKeyword.js

@@ -3,19 +3,21 @@ import { SymbolType } from '../../../types/issues.js';
 import { compact } from '../../../util/array.js';
 import { isGetOrSetAccessorDeclaration, isPrivateMember, stripQuotes } from '../../ast-helpers.js';
 import { exportVisitor as visit } from '../index.js';
-export default visit(() => true, node => {
-    const modifierKinds = node.modifiers?.map(modifier => modifier.kind) ?? [];
-    if (modifierKinds.includes(ts.SyntaxKind.ExportKeyword)) {
+export default visit(() => true, (node, { isFixExports, isFixTypes }) => {
+    const exportKeyword = node.modifiers?.find(mod => mod.kind === ts.SyntaxKind.ExportKeyword);
+    if (exportKeyword) {
         if (ts.isVariableStatement(node)) {
             return node.declarationList.declarations.flatMap(declaration => {
                 if (ts.isObjectBindingPattern(declaration.name)) {
                     return compact(declaration.name.elements.map(element => {
                         if (ts.isIdentifier(element.name)) {
+                            const fix = isFixExports ? [element.getStart(), element.getEnd()] : [];
                             return {
                                 node: element,
                                 identifier: element.name.escapedText.toString(),
                                 type: SymbolType.UNKNOWN,
                                 pos: element.name.getStart(),
+                                fix,
                             };
                         }
                     }));
@@ -23,28 +25,47 @@ export default visit(() => true, node => {
                 else if (ts.isArrayBindingPattern(declaration.name)) {
                     return compact(declaration.name.elements.map(element => {
                         if (ts.isBindingElement(element)) {
+                            const fix = isFixExports ? [element.getStart(), element.getEnd()] : [];
                             return {
                                 node: element,
                                 identifier: element.getText(),
                                 type: SymbolType.UNKNOWN,
                                 pos: element.getStart(),
+                                fix,
                             };
                         }
                     }));
                 }
                 else {
                     const identifier = declaration.name.getText();
-                    return { node: declaration, identifier, type: SymbolType.UNKNOWN, pos: declaration.name.getStart() };
+                    const fix = isFixExports ? [exportKeyword.getStart(), exportKeyword.getEnd() + 1] : [];
+                    return {
+                        node: declaration,
+                        identifier,
+                        type: SymbolType.UNKNOWN,
+                        pos: declaration.name.getStart(),
+                        fix,
+                    };
                 }
             });
         }
+        const defaultKeyword = node.modifiers?.find(mod => mod.kind === ts.SyntaxKind.DefaultKeyword);
         if (ts.isFunctionDeclaration(node) && node.name) {
-            const identifier = modifierKinds.includes(ts.SyntaxKind.DefaultKeyword) ? 'default' : node.name.getText();
+            const identifier = defaultKeyword ? 'default' : node.name.getText();
             const pos = (node.name ?? node.body ?? node).getStart();
-            return { node, identifier, pos, type: SymbolType.FUNCTION };
+            const fix = isFixExports
+                ? [exportKeyword.getStart(), (defaultKeyword ?? exportKeyword).getEnd() + 1]
+                : [];
+            return {
+                node,
+                identifier,
+                pos,
+                type: SymbolType.FUNCTION,
+                fix,
+            };
         }
         if (ts.isClassDeclaration(node) && node.name) {
-            const identifier = modifierKinds.includes(ts.SyntaxKind.DefaultKeyword) ? 'default' : node.name.getText();
+            const identifier = defaultKeyword ? 'default' : node.name.getText();
             const pos = (node.name ?? node).getStart();
             const members = node.members
                 .filter((member) => (ts.isPropertyDeclaration(member) ||
@@ -56,25 +77,59 @@ export default visit(() => true, node => {
                 identifier: member.name.getText(),
                 pos: member.name.getStart(),
                 type: SymbolType.MEMBER,
+                fix: [],
             }));
-            return { node, identifier, type: SymbolType.CLASS, pos, members };
+            const fix = isFixExports
+                ? [exportKeyword.getStart(), (defaultKeyword ?? exportKeyword).getEnd() + 1]
+                : [];
+            return {
+                node,
+                identifier,
+                type: SymbolType.CLASS,
+                pos,
+                members,
+                fix,
+            };
         }
         if (ts.isTypeAliasDeclaration(node)) {
-            return { node, identifier: node.name.getText(), type: SymbolType.TYPE, pos: node.name.getStart() };
+            const fix = isFixTypes ? [exportKeyword.getStart(), exportKeyword.getEnd() + 1] : [];
+            return {
+                node,
+                identifier: node.name.getText(),
+                type: SymbolType.TYPE,
+                pos: node.name.getStart(),
+                fix,
+            };
         }
         if (ts.isInterfaceDeclaration(node)) {
-            return { node, identifier: node.name.getText(), type: SymbolType.INTERFACE, pos: node.name.getStart() };
+            const fix = isFixTypes ? [exportKeyword.getStart(), exportKeyword.getEnd() + 1] : [];
+            return {
+                node,
+                identifier: node.name.getText(),
+                type: SymbolType.INTERFACE,
+                pos: node.name.getStart(),
+                fix,
+            };
         }
         if (ts.isEnumDeclaration(node)) {
-            const identifier = modifierKinds.includes(ts.SyntaxKind.DefaultKeyword) ? 'default' : node.name.getText();
+            const identifier = defaultKeyword ? 'default' : node.name.getText();
             const pos = node.name.getStart();
             const members = node.members.map(member => ({
                 node: member,
                 identifier: stripQuotes(member.name.getText()),
                 pos: member.name.getStart(),
                 type: SymbolType.MEMBER,
+                fix: [],
             }));
-            return { node, identifier, type: SymbolType.ENUM, pos, members };
+            const fix = isFixTypes ? [exportKeyword.getStart(), exportKeyword.getEnd() + 1] : [];
+            return {
+                node,
+                identifier,
+                type: SymbolType.ENUM,
+                pos,
+                members,
+                fix,
+            };
         }
     }
 });

package/dist/typescript/visitors/exports/moduleExportsAccessExpression.js

@@ -4,7 +4,7 @@ import { stripQuotes } from '../../ast-helpers.js';
 import { isJS } from '../helpers.js';
 import { exportVisitor as visit } from '../index.js';
 const isModuleExportsAccess = (node) => ts.isIdentifier(node.expression) && node.expression.escapedText === 'module' && node.name.escapedText === 'exports';
-export default visit(isJS, node => {
+export default visit(isJS, (node, { isFixExports }) => {
     if (ts.isExpressionStatement(node)) {
         if (ts.isBinaryExpression(node.expression)) {
             if (ts.isPropertyAccessExpression(node.expression.left)) {
@@ -12,17 +12,25 @@ export default visit(isJS, node => {
                     isModuleExportsAccess(node.expression.left.expression)) {
                     const identifier = node.expression.left.name.getText();
                     const pos = node.expression.left.name.pos;
-                    return { node, identifier, type: SymbolType.UNKNOWN, pos };
+                    const fix = isFixExports ? [node.getStart(), node.getEnd()] : [];
+                    return {
+                        node: node.expression.left.name,
+                        identifier,
+                        type: SymbolType.UNKNOWN,
+                        pos,
+                        fix,
+                    };
                 }
                 else if (isModuleExportsAccess(node.expression.left)) {
                     const expr = node.expression.right;
                     if (ts.isObjectLiteralExpression(expr) && expr.properties.every(ts.isShorthandPropertyAssignment)) {
                         return expr.properties.map(node => {
-                            return { node, identifier: node.getText(), type: SymbolType.UNKNOWN, pos: node.pos };
+                            const fix = isFixExports ? [node.getStart(), node.getEnd()] : [];
+                            return { node, identifier: node.getText(), type: SymbolType.UNKNOWN, pos: node.pos, fix };
                         });
                     }
                     else {
-                        return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos: expr.pos };
+                        return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos: expr.pos, fix: [] };
                     }
                 }
             }
@@ -32,7 +40,14 @@ export default visit(isJS, node => {
                 isModuleExportsAccess(node.expression.left.expression)) {
                 const identifier = stripQuotes(node.expression.left.argumentExpression.getText());
                 const pos = node.expression.left.argumentExpression.pos;
-                return { node, identifier, type: SymbolType.UNKNOWN, pos };
+                const fix = isFixExports ? [node.getStart(), node.getEnd()] : [];
+                return {
+                    node: node.expression.left.argumentExpression,
+                    identifier,
+                    type: SymbolType.UNKNOWN,
+                    pos,
+                    fix,
+                };
             }
         }
     }

package/dist/typescript/visitors/imports/jsDocType.js

@@ -1,42 +1,25 @@
 import ts from 'typescript';
 import { importVisitor as visit } from '../index.js';
 const extractImportSpecifiers = (node) => {
-    const importSpecifiers = [];
+    const imports = [];
     function visit(node) {
-        if (ts.isJSDocTypeExpression(node)) {
-            const typeNode = node.type;
-            if (ts.isTypeReferenceNode(typeNode) && typeNode.typeArguments) {
-                typeNode.typeArguments.forEach(arg => {
-                    if (ts.isImportTypeNode(arg)) {
-                        const importClause = arg.argument;
-                        if (ts.isLiteralTypeNode(importClause) && ts.isStringLiteral(importClause.literal)) {
-                            importSpecifiers.push(importClause.literal.text);
-                        }
-                    }
-                });
-            }
-        }
-        if (ts.isJSDocTypeTag(node)) {
-            const typeNode = node.typeExpression?.type;
-            if (ts.isImportTypeNode(typeNode)) {
-                const importClause = typeNode.argument;
-                if (ts.isLiteralTypeNode(importClause) && ts.isStringLiteral(importClause.literal)) {
-                    importSpecifiers.push(importClause.literal.text);
-                }
+        if (ts.isImportTypeNode(node)) {
+            const importClause = node.argument;
+            if (ts.isLiteralTypeNode(importClause) && ts.isStringLiteral(importClause.literal)) {
+                const identifier = node.qualifier && ts.isIdentifier(node.qualifier) ? String(node.qualifier.escapedText) : 'default';
+                imports.push({ specifier: importClause.literal.text, identifier });
             }
         }
         ts.forEachChild(node, visit);
     }
     visit(node);
-    return importSpecifiers;
+    return imports;
 };
 export default visit(() => true, node => {
     if ('jsDoc' in node && node.jsDoc) {
         const jsDoc = node.jsDoc;
         if (jsDoc.length > 0 && jsDoc[0].parent.parent === node.parent) {
-            return jsDoc
-                .flatMap(jsDoc => (jsDoc.tags ?? []).flatMap(extractImportSpecifiers))
-                .map(specifier => ({ specifier }));
+            return jsDoc.flatMap(jsDoc => (jsDoc.tags ?? []).flatMap(extractImportSpecifiers));
         }
     }
     return [];

package/dist/util/cli-arguments.d.ts

@@ -1,4 +1,4 @@
-export declare const helpText = "\u2702\uFE0F  Find unused files, dependencies and exports in your JavaScript and TypeScript projects\n\nUsage: knip [options]\n\nOptions:\n  -c, --config [file]      Configuration file path (default: [.]knip.json[c], knip.js, knip.ts or package.json#knip)\n  -t, --tsConfig [file]    TypeScript configuration path (default: tsconfig.json)\n  --production             Analyze only production source files (e.g. no tests, devDependencies, exported types)\n  --strict                 Consider only direct dependencies of workspace (not devDependencies, not other workspaces)\n  -W, --workspace [dir]    Analyze a single workspace (default: analyze all configured workspaces)\n  --directory [dir]        Run process from a different directory (default: cwd)\n  --no-gitignore           Don't use .gitignore\n  --include                Report only provided issue type(s), can be comma-separated or repeated (1)\n  --exclude                Exclude provided issue type(s) from report, can be comma-separated or repeated (1)\n  --dependencies           Shortcut for --include dependencies,unlisted,binaries,unresolved\n  --exports                Shortcut for --include exports,nsExports,classMembers,types,nsTypes,enumMembers,duplicates\n  --include-entry-exports  Include entry files when reporting unused exports\n  --isolate-workspaces     Isolated workspaces in monorepo\n  -n, --no-progress        Don't show dynamic progress updates (automatically enabled in CI environments)\n  --preprocessor           Preprocess the results before providing it to the reporter(s), can be repeated\n  --preprocessor-options   Pass extra options to the preprocessor (as JSON string, see --reporter-options example)\n  --reporter               Select reporter: symbols, compact, codeowners, json, can be repeated (default: symbols)\n  --reporter-options       Pass extra options to the reporter (as JSON string, see example)\n  --no-config-hints        Suppress configuration hints\n  --no-exit-code           Always exit with code zero (0)\n  --max-issues             Maximum number of issues before non-zero exit code (default: 0)\n  -d, --debug              Show debug output\n  --performance            Measure count and running time of expensive functions and display stats table\n  -h, --help               Print this help text\n  -V, --version            Print version\n\n(1) Issue types: files, dependencies, unlisted, unresolved, exports, nsExports, classMembers, types, nsTypes, enumMembers, duplicates\n\nExamples:\n\n$ knip\n$ knip --production\n$ knip --workspace packages/client --include files,dependencies\n$ knip -c ./config/knip.json --reporter compact\n$ knip --reporter codeowners --reporter-options '{\"path\":\".github/CODEOWNERS\"}'\n\nWebsite: https://knip.dev";
+export declare const helpText = "\u2702\uFE0F  Find unused files, dependencies and exports in your JavaScript and TypeScript projects\n\nUsage: knip [options]\n\nOptions:\n  -c, --config [file]      Configuration file path (default: [.]knip.json[c], knip.js, knip.ts or package.json#knip)\n  -t, --tsConfig [file]    TypeScript configuration path (default: tsconfig.json)\n  --production             Analyze only production source files (e.g. no tests, devDependencies, exported types)\n  --strict                 Consider only direct dependencies of workspace (not devDependencies, not other workspaces)\n  -W, --workspace [dir]    Analyze a single workspace (default: analyze all configured workspaces)\n  --directory [dir]        Run process from a different directory (default: cwd)\n  --no-gitignore           Don't use .gitignore\n  --include                Report only provided issue type(s), can be comma-separated or repeated (1)\n  --exclude                Exclude provided issue type(s) from report, can be comma-separated or repeated (1)\n  --dependencies           Shortcut for --include dependencies,unlisted,binaries,unresolved\n  --exports                Shortcut for --include exports,nsExports,classMembers,types,nsTypes,enumMembers,duplicates\n  --fix                    Fix issues\n  --fix-type               Fix only issues of type, can be comma-separated or repeated (2)\n  --include-entry-exports  Include entry files when reporting unused exports\n  --isolate-workspaces     Isolated workspaces in monorepo\n  -n, --no-progress        Don't show dynamic progress updates (automatically enabled in CI environments)\n  --preprocessor           Preprocess the results before providing it to the reporter(s), can be repeated\n  --preprocessor-options   Pass extra options to the preprocessor (as JSON string, see --reporter-options example)\n  --reporter               Select reporter: symbols, compact, codeowners, json, can be repeated (default: symbols)\n  --reporter-options       Pass extra options to the reporter (as JSON string, see example)\n  --no-config-hints        Suppress configuration hints\n  --no-exit-code           Always exit with code zero (0)\n  --max-issues             Maximum number of issues before non-zero exit code (default: 0)\n  -d, --debug              Show debug output\n  --performance            Measure count and running time of expensive functions and display stats table\n  -h, --help               Print this help text\n  -V, --version            Print version\n\n(1) Issue types: files, dependencies, unlisted, unresolved, exports, nsExports, classMembers, types, nsTypes, enumMembers, duplicates\n(2) Fixable issue types: dependencies, exports, types\n\nExamples:\n\n$ knip\n$ knip --production\n$ knip --workspace packages/client --include files,dependencies\n$ knip -c ./config/knip.json --reporter compact\n$ knip --reporter codeowners --reporter-options '{\"path\":\".github/CODEOWNERS\"}'\n\nWebsite: https://knip.dev";
 declare const _default: {
     config: string | undefined;
     debug: boolean | undefined;
@@ -6,6 +6,8 @@ declare const _default: {
     directory: string | undefined;
     exclude: string[] | undefined;
     exports: boolean | undefined;
+    fix: boolean | undefined;
+    'fix-type': string[] | undefined;
     help: boolean | undefined;
     'ignore-internal': boolean | undefined;
     include: string[] | undefined;

package/dist/util/cli-arguments.js

@@ -15,6 +15,8 @@ Options:
   --exclude                Exclude provided issue type(s) from report, can be comma-separated or repeated (1)
   --dependencies           Shortcut for --include dependencies,unlisted,binaries,unresolved
   --exports                Shortcut for --include exports,nsExports,classMembers,types,nsTypes,enumMembers,duplicates
+  --fix                    Fix issues
+  --fix-type               Fix only issues of type, can be comma-separated or repeated (2)
   --include-entry-exports  Include entry files when reporting unused exports
   --isolate-workspaces     Isolated workspaces in monorepo
   -n, --no-progress        Don't show dynamic progress updates (automatically enabled in CI environments)
@@ -31,6 +33,7 @@ Options:
   -V, --version            Print version
 
 (1) Issue types: files, dependencies, unlisted, unresolved, exports, nsExports, classMembers, types, nsTypes, enumMembers, duplicates
+(2) Fixable issue types: dependencies, exports, types
 
 Examples:
 
@@ -51,6 +54,8 @@ try {
             directory: { type: 'string' },
             exclude: { type: 'string', multiple: true },
             exports: { type: 'boolean' },
+            fix: { type: 'boolean' },
+            'fix-type': { type: 'string', multiple: true },
             help: { type: 'boolean', short: 'h' },
             'ignore-internal': { type: 'boolean' },
             include: { type: 'string', multiple: true },

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.6.1";
+export declare const version = "3.7.1";

package/dist/version.js

@@ -1 +1 @@
-export const version = '3.6.1';
+export const version = '3.7.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "3.6.1",
+  "version": "3.7.1",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {
@@ -55,6 +55,7 @@
   "dependencies": {
     "@ericcornelissen/bash-parser": "0.5.2",
     "@npmcli/map-workspaces": "3.0.4",
+    "@npmcli/package-json": "5.0.0",
     "@pkgjs/parseargs": "0.11.0",
     "@pnpm/logger": "5.0.0",
     "@pnpm/workspace.pkgs-graph": "^2.0.11",
@@ -80,7 +81,6 @@
   "devDependencies": {
     "@jest/types": "29.6.3",
     "@knip/eslint-config": "0.0.0",
-    "@npmcli/package-json": "5.0.0",
     "@release-it/bumper": "^6.0.1",
     "@swc/cli": "^0.1.63",
     "@swc/core": "^1.3.100",