knip 5.4.0 → 5.5.0

package/dist/index.js

@@ -8,10 +8,12 @@ import { IssueFixer } from './IssueFixer.js';
 import { getFilteredScripts } from './manifest/helpers.js';
 import { PrincipalFactory } from './PrincipalFactory.js';
 import { ProjectPrincipal } from './ProjectPrincipal.js';
-import { debugLogObject, debugLogArray, debugLog, exportLookupLog } from './util/debug.js';
+import { debugLogObject, debugLogArray, debugLog } from './util/debug.js';
+import { getReExportingEntryFileHandler } from './util/get-reexporting-entry-file.js';
 import { _glob, negate } from './util/glob.js';
 import { getGitIgnoredFn } from './util/globby.js';
-import { getHandler } from './util/handleReferencedDependency.js';
+import { getHandler } from './util/handle-dependency.js';
+import { getIsIdentifierReferencedHandler } from './util/is-identifier-referenced.js';
 import { getEntryPathFromManifest, getPackageNameFromModuleSpecifier } from './util/modules.js';
 import { dirname, join } from './util/path.js';
 import { hasMatch } from './util/regex.js';
@@ -168,7 +170,6 @@ export const main = async (unresolvedConfiguration) => {
     const importedSymbols = {};
     const unreferencedFiles = new Set();
     const entryPaths = new Set();
-    const exportedClasses = new Set();
     for (const principal of principals) {
         principal.init();
         const handleReferencedDependency = getHandler(collector, deputy, chief);
@@ -277,93 +278,8 @@ export const main = async (unresolvedConfiguration) => {
         if (isSkipLibs)
             factory.deletePrincipal(principal);
     }
-    const isIdentifierReferenced = (filePath, id, importsForExport, depth = 0) => {
-        if (!importsForExport) {
-            exportLookupLog(depth, `no imports found from`, filePath);
-            return false;
-        }
-        if (importsForExport.identifiers.has(id)) {
-            exportLookupLog(depth, `imported from`, filePath);
-            return true;
-        }
-        for (const ns of importsForExport.importedNs) {
-            if (importsForExport.identifiers.has(`${ns}.${id}`)) {
-                exportLookupLog(depth, `imported on ${ns} from`, filePath);
-                return true;
-            }
-        }
-        if (importsForExport.isReExport) {
-            for (const filePath of importsForExport.isReExportedBy) {
-                if (isIdentifierReferenced(filePath, id, importedSymbols[filePath], depth + 1)) {
-                    exportLookupLog(depth, `re-exported by`, filePath);
-                    return true;
-                }
-            }
-            for (const [filePath, alias] of importsForExport.isReExportedAs) {
-                if (isIdentifierReferenced(filePath, alias, importedSymbols[filePath], depth + 1)) {
-                    exportLookupLog(depth, `re-exported as ${alias} by`, filePath);
-                    return true;
-                }
-            }
-            for (const [filePath, ns] of importsForExport.isReExportedNs) {
-                if (isIdentifierReferenced(filePath, `${ns}.${id}`, importedSymbols[filePath], depth + 1)) {
-                    exportLookupLog(depth, `re-exported on ${ns} by`, filePath);
-                    return true;
-                }
-            }
-        }
-        exportLookupLog(depth, `not imported from`, filePath);
-        return false;
-    };
-    const getReExportingEntryFile = (importedModule, id, depth = 0) => {
-        if (!importedModule)
-            return undefined;
-        if (importedModule.isReExport) {
-            for (const filePath of importedModule.isReExportedBy) {
-                if (entryPaths.has(filePath)) {
-                    if (filePath in exportedSymbols && id in exportedSymbols[filePath]) {
-                        exportLookupLog(depth, `re-exported by entry`, filePath);
-                        return filePath;
-                    }
-                    else if (importedModule.hasStar) {
-                        exportLookupLog(depth, `re-exported (*) by entry`, filePath);
-                        return filePath;
-                    }
-                }
-                else {
-                    exportLookupLog(depth, `re-exported by`, filePath);
-                    const file = getReExportingEntryFile(importedSymbols[filePath], id, depth + 1);
-                    if (file)
-                        return file;
-                }
-            }
-            for (const [filePath, namespace] of importedModule.isReExportedNs) {
-                if (entryPaths.has(filePath)) {
-                    exportLookupLog(depth, `re-exported on ${namespace} by entry`, filePath);
-                    return filePath;
-                }
-                else {
-                    exportLookupLog(depth, `re-exported on ${namespace} by`, filePath);
-                    const file = getReExportingEntryFile(importedSymbols[filePath], namespace, depth + 1);
-                    if (file)
-                        return file;
-                }
-            }
-            for (const [filePath, alias] of importedModule.isReExportedAs) {
-                if (entryPaths.has(filePath)) {
-                    exportLookupLog(depth, `re-exported as ${alias} by entry`, filePath);
-                    return filePath;
-                }
-                else {
-                    exportLookupLog(depth, `re-exported as ${alias} by`, filePath);
-                    const file = getReExportingEntryFile(importedSymbols[filePath], alias, depth + 1);
-                    if (file)
-                        return file;
-                }
-            }
-        }
-        exportLookupLog(depth, `${id} is not re-exported by entry file`, '');
-    };
+    const isIdentifierReferenced = getIsIdentifierReferencedHandler(importedSymbols);
+    const getReExportingEntryFile = getReExportingEntryFileHandler(entryPaths, exportedSymbols, importedSymbols);
     const isExportedItemReferenced = (exportedItem) => {
         return (exportedItem.refs > 0 &&
             (typeof chief.config.ignoreExportsUsedInFile === 'object'
@@ -374,6 +290,7 @@ export const main = async (unresolvedConfiguration) => {
         streamer.cast('Analyzing source files...');
         for (const [filePath, exportItems] of Object.entries(exportedSymbols)) {
             const workspace = chief.findWorkspaceByFilePath(filePath);
+            const principal = workspace && factory.getPrincipalByPackageName(workspace.pkgName);
             if (workspace) {
                 const { isIncludeEntryExports } = workspace.config;
                 if (!isIncludeEntryExports && entryPaths.has(filePath))
@@ -390,20 +307,17 @@ export const main = async (unresolvedConfiguration) => {
                         continue;
                     if (importsForExport) {
                         if (!isIncludeEntryExports) {
-                            exportLookupLog(-1, `Looking up re-exporting file for ${identifier} from`, filePath);
-                            if (getReExportingEntryFile(importsForExport, identifier))
+                            if (getReExportingEntryFile(importsForExport, identifier, 0, filePath))
                                 continue;
                         }
-                        exportLookupLog(-1, `Looking up ${identifier} export from`, filePath);
                         if (isIdentifierReferenced(filePath, identifier, importsForExport)) {
-                            if (exportedItem.type === 'enum') {
+                            if (report.enumMembers && exportedItem.type === 'enum') {
                                 exportedItem.members?.forEach(member => {
                                     if (hasMatch(workspace.ignoreMembers, member.identifier))
                                         return;
                                     if (shouldIgnore(member.jsDocTags, tags))
                                         return;
                                     if (member.refs === 0) {
-                                        exportLookupLog(-1, `Looking up export member ${identifier}.${member.identifier} from`, filePath);
                                         if (!isIdentifierReferenced(filePath, `${identifier}.${member.identifier}`, importsForExport)) {
                                             collector.addIssue({
                                                 type: 'enumMembers',
@@ -419,7 +333,18 @@ export const main = async (unresolvedConfiguration) => {
                                 });
                             }
                             if (isReportClassMembers && exportedItem.type === 'class') {
-                                exportedClasses.add([filePath, exportedItem]);
+                                const members = exportedItem.members.filter(member => !hasMatch(workspace.ignoreMembers, member.identifier) && !shouldIgnore(member.jsDocTags, tags));
+                                principal?.findUnusedMembers(filePath, members).forEach(member => {
+                                    collector.addIssue({
+                                        type: 'classMembers',
+                                        filePath,
+                                        symbol: member.identifier,
+                                        parentSymbol: exportedItem.identifier,
+                                        pos: member.pos,
+                                        line: member.line,
+                                        col: member.col,
+                                    });
+                                });
                             }
                             continue;
                         }
@@ -429,11 +354,8 @@ export const main = async (unresolvedConfiguration) => {
                     if (hasStrictlyNsReferences && ((!report.nsTypes && isType) || (!report.nsExports && !isType)))
                         continue;
                     if (!isExportedItemReferenced(exportedItem)) {
-                        if (!isSkipLibs) {
-                            const principal = factory.getPrincipalByPackageName(workspace.pkgName);
-                            if (principal?.hasReferences(filePath, exportedItem))
-                                continue;
-                        }
+                        if (!isSkipLibs && principal?.hasReferences(filePath, exportedItem))
+                            continue;
                         const type = getType(hasStrictlyNsReferences, isType);
                         collector.addIssue({
                             type,
@@ -469,27 +391,6 @@ export const main = async (unresolvedConfiguration) => {
     const unusedIgnoredWorkspaces = chief.getUnusedIgnoredWorkspaces();
     unusedIgnoredWorkspaces.forEach(identifier => collector.addConfigurationHint({ type: 'ignoreWorkspaces', identifier }));
     const { issues, counters, configurationHints } = collector.getIssues();
-    if (isReportClassMembers) {
-        streamer.cast('Validating expensive classy memberships...');
-        for (const [filePath, exportedItem] of exportedClasses) {
-            const workspace = chief.findWorkspaceByFilePath(filePath);
-            const principal = workspace && factory.getPrincipalByPackageName(workspace.pkgName);
-            if (principal) {
-                const members = exportedItem.members.filter(member => !hasMatch(workspace.ignoreMembers, member.identifier) && !shouldIgnore(member.jsDocTags, tags));
-                principal.findUnusedMembers(filePath, members).forEach(member => {
-                    collector.addIssue({
-                        type: 'classMembers',
-                        filePath,
-                        symbol: member.identifier,
-                        parentSymbol: exportedItem.identifier,
-                        pos: member.pos,
-                        line: member.line,
-                        col: member.col,
-                    });
-                });
-            }
-        }
-    }
     if (isFix) {
         await fixer.fixIssues(issues);
     }

package/dist/manifest/index.js

@@ -1,7 +1,7 @@
 import { isDefinitelyTyped } from '../util/modules.js';
 import { timerify } from '../util/Performance.js';
 import { loadPackageManifest } from './helpers.js';
-const _getDependencyMetaData = ({ cwd, dir, packageNames }) => {
+const getMetaDataFromPackageJson = ({ cwd, dir, packageNames }) => {
     const hostDependencies = new Map();
     const installedBinaries = new Map();
     const hasTypesIncluded = new Set();
@@ -47,4 +47,4 @@ const _getDependencyMetaData = ({ cwd, dir, packageNames }) => {
         hasTypesIncluded,
     };
 };
-export const getDependencyMetaData = timerify(_getDependencyMetaData);
+export const getDependencyMetaData = timerify(getMetaDataFromPackageJson);

package/dist/typescript/SourceFile.d.ts

@@ -5,7 +5,15 @@ type SymbolWithExports = ts.Symbol & {
 };
 type PragmaMap = {
     arguments: {
-        factory: string;
+        factory?: string;
+        path?: {
+            value?: string;
+            pos?: number;
+        };
+        types?: {
+            value?: string;
+            pos?: number;
+        };
     };
 };
 export interface BoundSourceFile extends ts.SourceFile {

package/dist/typescript/getImportsAndExports.js

@@ -7,7 +7,7 @@ import { shouldIgnore } from '../util/tag.js';
 import { isAccessExpression, getJSDocTags, getLineAndCharacterOfPosition, getMemberStringLiterals, } from './ast-helpers.js';
 import getDynamicImportVisitors from './visitors/dynamic-imports/index.js';
 import getExportVisitors from './visitors/exports/index.js';
-import { getJSXImplicitImportBase } from './visitors/helpers.js';
+import { getImportsFromPragmas } from './visitors/helpers.js';
 import getImportVisitors from './visitors/imports/index.js';
 import getScriptVisitors from './visitors/scripts/index.js';
 const getVisitors = (sourceFile) => ({
@@ -39,9 +39,6 @@ const getImportsAndExports = (sourceFile, getResolvedModule, typeChecker, option
     const aliasedExports = new Map();
     const scripts = new Set();
     const importedInternalSymbols = new Map();
-    const jsxImport = getJSXImplicitImportBase(sourceFile);
-    if (jsxImport)
-        externalImports.add(jsxImport);
     const visitors = getVisitors(sourceFile);
     const addInternalImport = (options) => {
         const { identifier, specifier, symbol, filePath, namespace, isReExport } = options;
@@ -288,6 +285,9 @@ const getImportsAndExports = (sourceFile, getResolvedModule, typeChecker, option
         ts.forEachChild(node, visit);
     };
     visit(sourceFile);
+    const pragmaImports = getImportsFromPragmas(sourceFile);
+    if (pragmaImports)
+        pragmaImports.forEach(node => addImport(node, sourceFile));
     const setRefs = (item) => {
         if (!item.symbol)
             return;

package/dist/typescript/resolveModuleNames.js

@@ -42,7 +42,7 @@ export function createCustomModuleResolver(customSys, compilerOptions, virtualFi
                 const resolvedFileName = tsResolvedModule.resolvedFileName.replace(/\.d\.mts$/, '.mjs');
                 return { resolvedFileName, extension: '.mjs', isExternalLibraryImport: false, resolvedUsingTsExtension: false };
             }
-            if (tsResolvedModule.extension === '.d.cts') {
+            else if (tsResolvedModule.extension === '.d.cts') {
                 const resolvedFileName = tsResolvedModule.resolvedFileName.replace(/\.d\.cts$/, '.cjs');
                 return { resolvedFileName, extension: '.cjs', isExternalLibraryImport: false, resolvedUsingTsExtension: false };
             }

package/dist/typescript/visitors/dynamic-imports/importType.js

@@ -1,9 +1,9 @@
 import ts from 'typescript';
 import { importVisitor as visit } from '../index.js';
 export default visit(() => true, node => {
-    if (ts.isImportTypeNode(node) && node.isTypeOf) {
+    if (ts.isImportTypeNode(node)) {
         if (ts.isLiteralTypeNode(node.argument) && ts.isStringLiteral(node.argument.literal)) {
-            return { specifier: node.argument.literal.text, identifier: undefined, pos: 0 };
+            return { specifier: node.argument.literal.text, identifier: undefined, pos: 0, isTypeOnly: true };
         }
     }
 });

package/dist/typescript/visitors/helpers.d.ts

@@ -1,6 +1,7 @@
 import ts from 'typescript';
+import type { ImportNode } from '../../types/imports.js';
 import type { BoundSourceFile } from '../SourceFile.js';
 export declare const isNotJS: (sourceFile: BoundSourceFile) => boolean;
 export declare const isJS: (sourceFile: BoundSourceFile) => boolean;
-export declare function getJSXImplicitImportBase(sourceFile: BoundSourceFile): string | undefined;
+export declare function getImportsFromPragmas(sourceFile: BoundSourceFile): ImportNode[];
 export declare function hasImportSpecifier(node: ts.Statement, name: string): boolean;

package/dist/typescript/visitors/helpers.js

@@ -1,12 +1,31 @@
 import ts from 'typescript';
 export const isNotJS = (sourceFile) => sourceFile.scriptKind !== ts.ScriptKind.JS && sourceFile.scriptKind !== ts.ScriptKind.JSX;
 export const isJS = (sourceFile) => sourceFile.scriptKind === ts.ScriptKind.JS || sourceFile.scriptKind === ts.ScriptKind.JSX;
-export function getJSXImplicitImportBase(sourceFile) {
-    const jsxImportSourcePragmas = sourceFile.pragmas?.get('jsximportsource');
-    const jsxImportSourcePragma = Array.isArray(jsxImportSourcePragmas)
-        ? jsxImportSourcePragmas[jsxImportSourcePragmas.length - 1]
-        : jsxImportSourcePragmas;
-    return jsxImportSourcePragma?.arguments.factory;
+export function getImportsFromPragmas(sourceFile) {
+    const importNodes = [];
+    if (sourceFile.pragmas) {
+        const jsxImportSourcePragmas = sourceFile.pragmas.get('jsximportsource');
+        if (jsxImportSourcePragmas) {
+            const jsxImportSourcePragma = Array.isArray(jsxImportSourcePragmas)
+                ? jsxImportSourcePragmas[jsxImportSourcePragmas.length - 1]
+                : jsxImportSourcePragmas;
+            const { factory: specifier } = jsxImportSourcePragma?.arguments ?? {};
+            if (specifier)
+                importNodes.push({ specifier, isTypeOnly: true, identifier: '__jsx', pos: 0 });
+        }
+        const referencePragma = sourceFile.pragmas.get('reference');
+        if (referencePragma) {
+            const refs = [referencePragma].flat();
+            for (const ref of refs) {
+                if (ref.arguments?.types) {
+                    const { value: specifier, pos } = ref.arguments.types;
+                    if (specifier)
+                        importNodes.push({ specifier, isTypeOnly: true, identifier: undefined, pos });
+                }
+            }
+        }
+    }
+    return importNodes;
 }
 export function hasImportSpecifier(node, name) {
     return (ts.isImportDeclaration(node) &&

package/dist/util/get-reexporting-entry-file.d.ts

@@ -0,0 +1,3 @@
+import type { SerializableExportMap } from '../types/exports.js';
+import type { SerializableImportMap, SerializableImports } from '../types/imports.js';
+export declare const getReExportingEntryFileHandler: (entryPaths: Set<string>, exportedSymbols: SerializableExportMap, importedSymbols: SerializableImportMap) => (importedModule: SerializableImports | undefined, id: string, depth?: number, filePath?: string) => string | undefined;

package/dist/util/get-reexporting-entry-file.js

@@ -0,0 +1,55 @@
+import { exportLookupLog } from './debug.js';
+export const getReExportingEntryFileHandler = (entryPaths, exportedSymbols, importedSymbols) => {
+    const getReExportingEntryFile = (importedModule, id, depth = 0, filePath) => {
+        if (depth === 0 && filePath)
+            exportLookupLog(-1, `Looking up re-exporting file for ${id} from`, filePath);
+        if (!importedModule)
+            return undefined;
+        if (importedModule.isReExport) {
+            for (const filePath of importedModule.isReExportedBy) {
+                if (entryPaths.has(filePath)) {
+                    if (filePath in exportedSymbols && id in exportedSymbols[filePath]) {
+                        exportLookupLog(depth, `re-exported by entry`, filePath);
+                        return filePath;
+                    }
+                    else if (importedModule.hasStar) {
+                        exportLookupLog(depth, `re-exported (*) by entry`, filePath);
+                        return filePath;
+                    }
+                }
+                else {
+                    exportLookupLog(depth, `re-exported by`, filePath);
+                    const file = getReExportingEntryFile(importedSymbols[filePath], id, depth + 1);
+                    if (file)
+                        return file;
+                }
+            }
+            for (const [filePath, namespace] of importedModule.isReExportedNs) {
+                if (entryPaths.has(filePath)) {
+                    exportLookupLog(depth, `re-exported on ${namespace} by entry`, filePath);
+                    return filePath;
+                }
+                else {
+                    exportLookupLog(depth, `re-exported on ${namespace} by`, filePath);
+                    const file = getReExportingEntryFile(importedSymbols[filePath], namespace, depth + 1);
+                    if (file)
+                        return file;
+                }
+            }
+            for (const [filePath, alias] of importedModule.isReExportedAs) {
+                if (entryPaths.has(filePath)) {
+                    exportLookupLog(depth, `re-exported as ${alias} by entry`, filePath);
+                    return filePath;
+                }
+                else {
+                    exportLookupLog(depth, `re-exported as ${alias} by`, filePath);
+                    const file = getReExportingEntryFile(importedSymbols[filePath], alias, depth + 1);
+                    if (file)
+                        return file;
+                }
+            }
+        }
+        exportLookupLog(depth, `${id} is not re-exported by entry file`, '');
+    };
+    return getReExportingEntryFile;
+};

package/dist/util/globby.js

@@ -21,7 +21,7 @@ function convertGitignoreToMicromatch(pattern) {
         pattern = pattern.slice(5);
     if (pattern.startsWith('/'))
         pattern = pattern.slice(1);
-    else
+    else if (!pattern.startsWith('**/'))
         pattern = '**/' + pattern;
     if (pattern.endsWith('/*'))
         extPattern = pattern;
@@ -36,7 +36,7 @@ function parseGitignoreFile(filePath) {
     return file
         .split(/\r?\n/)
         .filter(line => line && !line.startsWith('#'))
-        .map(pattern => convertGitignoreToMicromatch(pattern));
+        .map(pattern => convertGitignoreToMicromatch(pattern.replace(/#.*/, '').trim()));
 }
 async function parseFindGitignores(options) {
     const ignores = ['.git', ...GLOBAL_IGNORE_PATTERNS];

package/dist/util/is-identifier-referenced.d.ts

@@ -0,0 +1,2 @@
+import type { SerializableImportMap, SerializableImports } from '../types/imports.js';
+export declare const getIsIdentifierReferencedHandler: (importedSymbols: SerializableImportMap) => (filePath: string, id: string, importsForExport?: SerializableImports, depth?: number) => boolean;

package/dist/util/is-identifier-referenced.js

@@ -0,0 +1,44 @@
+import { exportLookupLog } from './debug.js';
+export const getIsIdentifierReferencedHandler = (importedSymbols) => {
+    const isIdentifierReferenced = (filePath, id, importsForExport, depth = 0) => {
+        if (depth === 0)
+            exportLookupLog(-1, `Looking up export "${id}" from`, filePath);
+        if (!importsForExport) {
+            exportLookupLog(depth, `no imports found from`, filePath);
+            return false;
+        }
+        if (importsForExport.identifiers.has(id)) {
+            exportLookupLog(depth, `imported from`, filePath);
+            return true;
+        }
+        for (const ns of importsForExport.importedNs) {
+            if (importsForExport.identifiers.has(`${ns}.${id}`)) {
+                exportLookupLog(depth, `imported on ${ns} from`, filePath);
+                return true;
+            }
+        }
+        if (importsForExport.isReExport) {
+            for (const filePath of importsForExport.isReExportedBy) {
+                if (isIdentifierReferenced(filePath, id, importedSymbols[filePath], depth + 1)) {
+                    exportLookupLog(depth, `re-exported by`, filePath);
+                    return true;
+                }
+            }
+            for (const [filePath, alias] of importsForExport.isReExportedAs) {
+                if (isIdentifierReferenced(filePath, alias, importedSymbols[filePath], depth + 1)) {
+                    exportLookupLog(depth, `re-exported as ${alias} by`, filePath);
+                    return true;
+                }
+            }
+            for (const [filePath, ns] of importsForExport.isReExportedNs) {
+                if (isIdentifierReferenced(filePath, `${ns}.${id}`, importedSymbols[filePath], depth + 1)) {
+                    exportLookupLog(depth, `re-exported on ${ns} by`, filePath);
+                    return true;
+                }
+            }
+        }
+        exportLookupLog(depth, `not imported from`, filePath);
+        return false;
+    };
+    return isIdentifierReferenced;
+};

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.4.0";
+export declare const version = "5.5.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.4.0';
+export const version = '5.5.0';

package/package.json

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

package/schema.json

@@ -32,7 +32,7 @@
       "$ref": "#/definitions/list"
     },
     "ignoreMembers": {
-      "title": "Class members to ignore (regex allowed)",
+      "title": "Class and enum members to ignore (regex allowed)",
       "examples": ["render", "on.*"],
       "$ref": "#/definitions/list"
     },