knip 5.3.1 → 5.5.0

package/dist/ConfigurationChief.d.ts

@@ -1,5 +1,5 @@
 import { createPkgGraph } from '@pnpm/workspace.pkgs-graph';
-import type { Configuration, WorkspaceConfiguration } from './types/config.js';
+import type { Configuration, WorkspaceConfiguration, IgnorePatterns } from './types/config.js';
 import type { PackageJson } from './types/package-json.js';
 type ConfigurationManagerOptions = {
     cwd: string;
@@ -14,6 +14,7 @@ export type Workspace = {
     ancestors: string[];
     config: WorkspaceConfiguration;
     manifestPath: string;
+    ignoreMembers: IgnorePatterns;
 };
 export declare class ConfigurationChief {
     cwd: string;
@@ -63,6 +64,7 @@ export declare class ConfigurationChief {
     private getIgnoredWorkspacesFor;
     getNegatedWorkspacePatterns(name: string): string[];
     private getConfigKeyForWorkspace;
+    getWorkspaceConfig(workspaceName: string): any;
     getIgnores(workspaceName: string): {
         ignoreBinaries: (string | RegExp)[];
         ignoreDependencies: (string | RegExp)[];

package/dist/ConfigurationChief.js

@@ -37,6 +37,7 @@ const defaultConfig = {
     ignore: [],
     ignoreBinaries: [],
     ignoreDependencies: [],
+    ignoreMembers: [],
     ignoreExportsUsedInFile: false,
     ignoreWorkspaces: [],
     isIncludeEntryExports: false,
@@ -123,6 +124,7 @@ export class ConfigurationChief {
         const ignore = arrayify(rawConfig.ignore ?? defaultConfig.ignore);
         const ignoreBinaries = (rawConfig.ignoreBinaries ?? []).map(toRegexOrString);
         const ignoreDependencies = (rawConfig.ignoreDependencies ?? []).map(toRegexOrString);
+        const ignoreMembers = (rawConfig.ignoreMembers ?? []).map(toRegexOrString);
         const ignoreExportsUsedInFile = rawConfig.ignoreExportsUsedInFile ?? false;
         const ignoreWorkspaces = rawConfig.ignoreWorkspaces ?? defaultConfig.ignoreWorkspaces;
         const isIncludeEntryExports = rawConfig.includeEntryExports ?? this.isIncludeEntryExports;
@@ -141,6 +143,7 @@ export class ConfigurationChief {
             ignore,
             ignoreBinaries,
             ignoreDependencies,
+            ignoreMembers,
             ignoreExportsUsedInFile,
             ignoreWorkspaces,
             isIncludeEntryExports,
@@ -271,6 +274,8 @@ export class ConfigurationChief {
             .map((name) => {
             const dir = join(this.cwd, name);
             const pkgName = this.availableWorkspaceManifests.find(p => p.dir === dir)?.manifest.name ?? `NOT_FOUND_${name}`;
+            const workspaceConfig = this.getWorkspaceConfig(name);
+            const ignoreMembers = arrayify(workspaceConfig.ignoreMembers).map(toRegexOrString);
             return {
                 name,
                 pkgName,
@@ -278,6 +283,7 @@ export class ConfigurationChief {
                 config: this.getConfigForWorkspace(name),
                 ancestors: this.availableWorkspaceNames.reduce(getAncestors(name), []),
                 manifestPath: join(dir, 'package.json'),
+                ignoreMembers,
             };
         });
     }
@@ -311,27 +317,24 @@ export class ConfigurationChief {
             .reverse()
             .find(pattern => micromatch.isMatch(workspaceName, pattern));
     }
-    getIgnores(workspaceName) {
+    getWorkspaceConfig(workspaceName) {
         const key = this.getConfigKeyForWorkspace(workspaceName);
         const workspaces = this.rawConfig?.workspaces ?? {};
-        const workspaceConfig = (key
+        return ((key
             ? key === ROOT_WORKSPACE_NAME && !(ROOT_WORKSPACE_NAME in workspaces)
                 ? this.rawConfig
                 : workspaces[key]
-            : {}) ?? {};
+            : {}) ?? {});
+    }
+    getIgnores(workspaceName) {
+        const workspaceConfig = this.getWorkspaceConfig(workspaceName);
         const ignoreBinaries = arrayify(workspaceConfig.ignoreBinaries).map(toRegexOrString);
         const ignoreDependencies = arrayify(workspaceConfig.ignoreDependencies).map(toRegexOrString);
         return { ignoreBinaries, ignoreDependencies };
     }
     getConfigForWorkspace(workspaceName, extensions) {
         const baseConfig = getDefaultWorkspaceConfig(extensions);
-        const key = this.getConfigKeyForWorkspace(workspaceName);
-        const workspaces = this.rawConfig?.workspaces ?? {};
-        const workspaceConfig = (key
-            ? key === ROOT_WORKSPACE_NAME && !(ROOT_WORKSPACE_NAME in workspaces)
-                ? this.rawConfig
-                : workspaces[key]
-            : {}) ?? {};
+        const workspaceConfig = this.getWorkspaceConfig(workspaceName);
         const entry = workspaceConfig.entry ? arrayify(workspaceConfig.entry) : baseConfig.entry;
         const project = workspaceConfig.project ? arrayify(workspaceConfig.project) : baseConfig.project;
         const paths = workspaceConfig.paths ?? {};

package/dist/ConfigurationValidator.d.ts

@@ -21,6 +21,7 @@ export declare const ConfigurationValidator: z.ZodObject<{
     ignore: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
     ignoreBinaries: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, "many">>;
     ignoreDependencies: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, "many">>;
+    ignoreMembers: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, "many">>;
     ignoreExportsUsedInFile: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodRecord<z.ZodUnion<[z.ZodLiteral<"class">, z.ZodLiteral<"enum">, z.ZodLiteral<"function">, z.ZodLiteral<"interface">, z.ZodLiteral<"member">, z.ZodLiteral<"type">]>, z.ZodBoolean>]>>;
     ignoreWorkspaces: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     includeEntryExports: z.ZodOptional<z.ZodBoolean>;
@@ -35,6 +36,7 @@ export declare const ConfigurationValidator: z.ZodObject<{
         ignore: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
         ignoreBinaries: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, "many">>;
         ignoreDependencies: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, "many">>;
+        ignoreMembers: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, "many">>;
         includeEntryExports: z.ZodOptional<z.ZodBoolean>;
         astro: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
             config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
@@ -758,6 +760,7 @@ export declare const ConfigurationValidator: z.ZodObject<{
         ignore?: string | string[] | undefined;
         ignoreBinaries?: (string | RegExp)[] | undefined;
         ignoreDependencies?: (string | RegExp)[] | undefined;
+        ignoreMembers?: (string | RegExp)[] | undefined;
         includeEntryExports?: boolean | undefined;
         astro?: string | boolean | string[] | {
             config?: string | string[] | undefined;
@@ -1041,6 +1044,7 @@ export declare const ConfigurationValidator: z.ZodObject<{
         ignore?: string | string[] | undefined;
         ignoreBinaries?: (string | RegExp)[] | undefined;
         ignoreDependencies?: (string | RegExp)[] | undefined;
+        ignoreMembers?: (string | RegExp)[] | undefined;
         includeEntryExports?: boolean | undefined;
         astro?: string | boolean | string[] | {
             config?: string | string[] | undefined;
@@ -2042,6 +2046,7 @@ export declare const ConfigurationValidator: z.ZodObject<{
     ignore?: string | string[] | undefined;
     ignoreBinaries?: (string | RegExp)[] | undefined;
     ignoreDependencies?: (string | RegExp)[] | undefined;
+    ignoreMembers?: (string | RegExp)[] | undefined;
     ignoreExportsUsedInFile?: boolean | Partial<Record<"function" | "type" | "enum" | "class" | "interface" | "member", boolean>> | undefined;
     ignoreWorkspaces?: string[] | undefined;
     includeEntryExports?: boolean | undefined;
@@ -2056,6 +2061,7 @@ export declare const ConfigurationValidator: z.ZodObject<{
         ignore?: string | string[] | undefined;
         ignoreBinaries?: (string | RegExp)[] | undefined;
         ignoreDependencies?: (string | RegExp)[] | undefined;
+        ignoreMembers?: (string | RegExp)[] | undefined;
         includeEntryExports?: boolean | undefined;
         astro?: string | boolean | string[] | {
             config?: string | string[] | undefined;
@@ -2617,6 +2623,7 @@ export declare const ConfigurationValidator: z.ZodObject<{
     ignore?: string | string[] | undefined;
     ignoreBinaries?: (string | RegExp)[] | undefined;
     ignoreDependencies?: (string | RegExp)[] | undefined;
+    ignoreMembers?: (string | RegExp)[] | undefined;
     ignoreExportsUsedInFile?: boolean | Partial<Record<"function" | "type" | "enum" | "class" | "interface" | "member", boolean>> | undefined;
     ignoreWorkspaces?: string[] | undefined;
     includeEntryExports?: boolean | undefined;
@@ -2631,6 +2638,7 @@ export declare const ConfigurationValidator: z.ZodObject<{
         ignore?: string | string[] | undefined;
         ignoreBinaries?: (string | RegExp)[] | undefined;
         ignoreDependencies?: (string | RegExp)[] | undefined;
+        ignoreMembers?: (string | RegExp)[] | undefined;
         includeEntryExports?: boolean | undefined;
         astro?: string | boolean | string[] | {
             config?: string | string[] | undefined;

package/dist/ConfigurationValidator.js

@@ -41,6 +41,7 @@ const rootConfigurationSchema = z.object({
     ignore: globSchema.optional(),
     ignoreBinaries: stringOrRegexSchema.optional(),
     ignoreDependencies: stringOrRegexSchema.optional(),
+    ignoreMembers: stringOrRegexSchema.optional(),
     ignoreExportsUsedInFile: ignoreExportsUsedInFileSchema.optional(),
     ignoreWorkspaces: z.array(z.string()).optional(),
     includeEntryExports: z.boolean().optional(),
@@ -125,6 +126,7 @@ const baseWorkspaceConfigurationSchema = z.object({
     ignore: globSchema.optional(),
     ignoreBinaries: stringOrRegexSchema.optional(),
     ignoreDependencies: stringOrRegexSchema.optional(),
+    ignoreMembers: stringOrRegexSchema.optional(),
     includeEntryExports: z.boolean().optional(),
 });
 const workspaceConfigurationSchema = baseWorkspaceConfigurationSchema.merge(pluginsSchema.partial());

package/dist/compilers/index.d.ts

@@ -12,6 +12,7 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     ignore?: string | string[] | undefined;
     ignoreBinaries?: (string | RegExp)[] | undefined;
     ignoreDependencies?: (string | RegExp)[] | undefined;
+    ignoreMembers?: (string | RegExp)[] | undefined;
     ignoreExportsUsedInFile?: boolean | Partial<Record<"function" | "type" | "enum" | "class" | "interface" | "member", boolean>> | undefined;
     ignoreWorkspaces?: string[] | undefined;
     includeEntryExports?: boolean | undefined;
@@ -24,6 +25,7 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         ignore?: string | string[] | undefined;
         ignoreBinaries?: (string | RegExp)[] | undefined;
         ignoreDependencies?: (string | RegExp)[] | undefined;
+        ignoreMembers?: (string | RegExp)[] | undefined;
         includeEntryExports?: boolean | undefined;
         astro?: string | boolean | string[] | {
             config?: string | string[] | undefined;

package/dist/index.js

@@ -8,12 +8,15 @@ 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';
 import { shouldIgnore } from './util/tag.js';
 import { loadTSConfig } from './util/tsconfig-loader.js';
 import { getType, getHasStrictlyNsReferences } from './util/type.js';
@@ -167,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);
@@ -273,96 +275,11 @@ export const main = async (unresolvedConfiguration) => {
         });
         principal.getUnreferencedFiles().forEach(filePath => unreferencedFiles.add(filePath));
         principal.entryPaths.forEach(filePath => entryPaths.add(filePath));
-        if (!isReportClassMembers)
+        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'
@@ -373,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))
@@ -389,18 +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',
@@ -416,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;
                         }
@@ -426,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,
@@ -466,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 => !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/types/config.d.ts

@@ -34,6 +34,7 @@ export interface Configuration {
     ignoreBinaries: IgnorePatterns;
     ignoreDependencies: IgnorePatterns;
     ignoreExportsUsedInFile: boolean | Partial<Record<IgnorableExport, boolean>>;
+    ignoreMembers: IgnorePatterns;
     ignoreWorkspaces: string[];
     isIncludeEntryExports: boolean;
     syncCompilers: SyncCompilers;

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.3.1";
+export declare const version = "5.5.0";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.3.1",
+  "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

@@ -31,6 +31,11 @@
       "examples": ["husky", "lint-staged"],
       "$ref": "#/definitions/list"
     },
+    "ignoreMembers": {
+      "title": "Class and enum members to ignore (regex allowed)",
+      "examples": ["render", "on.*"],
+      "$ref": "#/definitions/list"
+    },
     "ignoreWorkspaces": {
       "title": "Workspaces to ignore",
       "examples": ["packages/ignore-me"],