knip 2.32.2 → 2.32.4

package/dist/ConfigurationChief.d.ts

@@ -1,7 +1,7 @@
-/// <reference types="npmcli__package-json" />
+import { createPkgGraph } from '@pnpm/workspace.pkgs-graph';
 import type { SyncCompilers, AsyncCompilers } from './types/compilers.js';
 import type { Configuration, WorkspaceConfiguration } from './types/config.js';
-import type { PackageJson } from '@npmcli/package-json';
+import type { PackageJsonWithPlugins } from './types/plugins.js';
 type ConfigurationManagerOptions = {
     cwd: string;
     isProduction: boolean;
@@ -12,26 +12,38 @@ export type Workspace = {
     dir: string;
     ancestors: string[];
     config: WorkspaceConfiguration;
+    manifestPath: string;
+    manifest: PackageJsonWithPlugins;
 };
 export declare class ConfigurationChief {
     cwd: string;
     isProduction: boolean;
     config: Configuration;
     manifestPath?: string;
-    manifest?: PackageJson;
+    manifest?: PackageJsonWithPlugins;
     ignoredWorkspacePatterns: string[];
     manifestWorkspaces: Map<string, string>;
     additionalWorkspaceNames: Set<string>;
     availableWorkspaceNames: string[];
+    availableWorkspacePkgNames: Set<string | undefined>;
     availableWorkspaceDirs: string[];
+    availableWorkspaceManifests: {
+        dir: string;
+        manifest: PackageJsonWithPlugins;
+    }[];
+    workspacesGraph: ReturnType<typeof createPkgGraph> | undefined;
     enabledWorkspaces: Workspace[];
-    localWorkspaces: Set<string>;
     resolvedConfigFilePath?: string;
     rawConfig?: any;
     constructor({ cwd, isProduction }: ConfigurationManagerOptions);
     init(): Promise<void>;
     getCompilers(): [SyncCompilers, AsyncCompilers];
     getRules(): import("./types/issues.js").Rules;
+    getFilters(): {
+        dir: string;
+    } | {
+        dir?: undefined;
+    };
     private normalize;
     private setWorkspaces;
     private getListedWorkspaces;
@@ -40,6 +52,7 @@ export declare class ConfigurationChief {
     private getConfiguredWorkspaceKeys;
     private getAdditionalWorkspaceNames;
     private getAvailableWorkspaceNames;
+    private getAvailableWorkspaceManifests;
     private getEnabledWorkspaces;
     getWorkspaces(): Workspace[];
     private getDescendentWorkspaces;
@@ -49,7 +62,6 @@ export declare class ConfigurationChief {
     private getConfigForWorkspace;
     getIssueTypesToReport(): import("./types/issues.js").Report;
     findWorkspaceByFilePath(filePath: string): Workspace | undefined;
-    findWorkspaceByPackageName(packageName: string): Workspace | undefined;
     getUnusedIgnoredWorkspaces(): string[];
 }
 export {};

package/dist/ConfigurationChief.js

@@ -1,14 +1,15 @@
 import { existsSync } from 'node:fs';
 import mapWorkspaces from '@npmcli/map-workspaces';
+import { createPkgGraph } from '@pnpm/workspace.pkgs-graph';
 import micromatch from 'micromatch';
 import { ConfigurationValidator } from './ConfigurationValidator.js';
 import { ROOT_WORKSPACE_NAME, DEFAULT_EXTENSIONS, KNIP_CONFIG_LOCATIONS } from './constants.js';
 import { defaultRules } from './issues/initializers.js';
 import * as plugins from './plugins/index.js';
-import { arrayify, compact } from './util/array.js';
+import { arrayify } from './util/array.js';
 import parsedArgValues from './util/cli-arguments.js';
 import { partitionCompilers } from './util/compilers.js';
-import { ConfigurationError } from './util/errors.js';
+import { ConfigurationError, LoaderError } from './util/errors.js';
 import { findFile, loadJSON } from './util/fs.js';
 import { getIncludedIssueTypes } from './util/get-included-issue-types.js';
 import { _dirGlob } from './util/glob.js';
@@ -16,6 +17,7 @@ import { _load } from './util/loader.js';
 import { getKeysByValue } from './util/object.js';
 import { join, relative, toPosix } from './util/path.js';
 import { normalizePluginConfig, toCamelCase } from './util/plugin.js';
+import { _require } from './util/require.js';
 import { byPathDepth } from './util/workspace.js';
 const { config: rawConfigArg, workspace: rawWorkspaceArg, include = [], exclude = [], dependencies = false, exports = false, } = parsedArgValues;
 const workspaceArg = rawWorkspaceArg ? toPosix(rawWorkspaceArg).replace(/^\.\//, '').replace(/\/$/, '') : undefined;
@@ -55,9 +57,11 @@ export class ConfigurationChief {
     manifestWorkspaces = new Map();
     additionalWorkspaceNames = new Set();
     availableWorkspaceNames = [];
+    availableWorkspacePkgNames = new Set();
     availableWorkspaceDirs = [];
+    availableWorkspaceManifests = [];
+    workspacesGraph;
     enabledWorkspaces = [];
-    localWorkspaces = new Set();
     resolvedConfigFilePath;
     rawConfig;
     constructor({ cwd, isProduction }) {
@@ -97,6 +101,11 @@ export class ConfigurationChief {
     getRules() {
         return this.config.rules;
     }
+    getFilters() {
+        if (this.workspacesGraph?.graph && workspaceArg)
+            return { dir: join(this.cwd, workspaceArg) };
+        return {};
+    }
     normalize(rawConfig) {
         const rules = { ...defaultRules, ...rawConfig.rules };
         const include = rawConfig.include ?? defaultConfig.include;
@@ -140,8 +149,10 @@ export class ConfigurationChief {
             .sort(byPathDepth)
             .reverse()
             .map(dir => join(this.cwd, dir));
+        this.availableWorkspaceManifests = this.getAvailableWorkspaceManifests(this.availableWorkspaceDirs);
+        this.availableWorkspacePkgNames = new Set(this.availableWorkspaceManifests.map(w => w.manifest.name));
+        this.workspacesGraph = createPkgGraph(this.availableWorkspaceManifests);
         this.enabledWorkspaces = this.getEnabledWorkspaces();
-        this.localWorkspaces = new Set(compact(this.enabledWorkspaces.map(w => w.pkgName)));
     }
     getListedWorkspaces() {
         return this.manifest?.workspaces
@@ -186,6 +197,14 @@ export class ConfigurationChief {
     getAvailableWorkspaceNames() {
         return [ROOT_WORKSPACE_NAME, ...this.manifestWorkspaces.keys(), ...this.additionalWorkspaceNames].filter(name => !micromatch.isMatch(name, this.ignoredWorkspacePatterns));
     }
+    getAvailableWorkspaceManifests(availableWorkspaceDirs) {
+        return availableWorkspaceDirs.map(dir => {
+            const manifest = _require(join(dir, 'package.json'));
+            if (!manifest)
+                throw new LoaderError(`Unable to load package.json for ${dir}`);
+            return { dir, manifest };
+        });
+    }
     getEnabledWorkspaces() {
         if (workspaceArg && !existsSync(workspaceArg)) {
             throw new ConfigurationError(`Directory does not exist: ${workspaceArg}`);
@@ -198,18 +217,42 @@ export class ConfigurationChief {
             return ancestors;
         };
         const workspaceNames = workspaceArg
-            ? [
-                ...this.availableWorkspaceNames.reduce(getAncestors(workspaceArg), []),
-                ...this.availableWorkspaceNames.filter(name => name === workspaceArg),
-            ]
+            ? [...this.availableWorkspaceNames.reduce(getAncestors(workspaceArg), []), workspaceArg]
             : this.availableWorkspaceNames;
-        return workspaceNames.sort(byPathDepth).map((name) => ({
-            name,
-            pkgName: this.manifestWorkspaces.get(name) ?? this.manifest?.name ?? `NOT_FOUND_${name}`,
-            dir: join(this.cwd, name),
-            config: this.getConfigForWorkspace(name),
-            ancestors: this.availableWorkspaceNames.reduce(getAncestors(name), []),
-        }));
+        const graph = this.workspacesGraph?.graph;
+        const ws = new Set();
+        if (graph && workspaceArg) {
+            const seen = new Set();
+            const initialWorkspaces = new Set(workspaceNames.map(name => join(this.cwd, name)));
+            const workspaceDirsWithDependants = new Set(initialWorkspaces);
+            const addDependents = (dir) => {
+                seen.add(dir);
+                const deps = graph[dir]?.dependencies ?? [];
+                if (deps.length > 0 && Array.from(initialWorkspaces).some(dir => deps.includes(dir))) {
+                    workspaceDirsWithDependants.add(dir);
+                }
+                deps.filter(dir => !seen.has(dir)).forEach(addDependents);
+            };
+            this.availableWorkspaceNames.map(name => join(this.cwd, name)).forEach(addDependents);
+            workspaceDirsWithDependants.forEach(dir => ws.add(relative(this.cwd, dir) || ROOT_WORKSPACE_NAME));
+        }
+        else {
+            workspaceNames.forEach(name => ws.add(name));
+        }
+        return Array.from(ws)
+            .sort(byPathDepth)
+            .map((name) => {
+            const dir = join(this.cwd, name);
+            return {
+                name,
+                pkgName: this.manifestWorkspaces.get(name) ?? this.manifest?.name ?? `NOT_FOUND_${name}`,
+                dir,
+                config: this.getConfigForWorkspace(name),
+                ancestors: this.availableWorkspaceNames.reduce(getAncestors(name), []),
+                manifestPath: join(dir, 'package.json'),
+                manifest: this.availableWorkspaceManifests?.find(item => item.dir === dir)?.manifest ?? {},
+            };
+        });
     }
     getWorkspaces() {
         return this.enabledWorkspaces;
@@ -281,9 +324,6 @@ export class ConfigurationChief {
         const workspaceDir = this.availableWorkspaceDirs.find(workspaceDir => filePath.startsWith(workspaceDir + '/'));
         return this.enabledWorkspaces.find(workspace => workspace.dir === workspaceDir);
     }
-    findWorkspaceByPackageName(packageName) {
-        return this.enabledWorkspaces.find(workspace => workspace.pkgName === packageName);
-    }
     getUnusedIgnoredWorkspaces() {
         const ignoredWorkspaceNames = this.config.ignoreWorkspaces;
         const workspaceNames = [...this.manifestWorkspaces.keys(), ...this.additionalWorkspaceNames];

package/dist/DependencyDeputy.js

@@ -233,9 +233,10 @@ export class DependencyDeputy {
             const installedBinaries = this.getInstalledBinaries(workspaceName);
             referencedDependencies?.forEach(pkg => pkg in rootIgnoreDependencies && rootIgnoreDependencies[pkg]++);
             referencedBinaries?.forEach(binaryName => binaryName in rootIgnoreBinaries && rootIgnoreBinaries[binaryName]++);
-            const dependencies = this.isStrict
-                ? this.getProductionDependencies(workspaceName)
-                : [...this.getProductionDependencies(workspaceName), ...this.getDevDependencies(workspaceName)];
+            const dependencies = [
+                ...this.getProductionDependencies(workspaceName),
+                ...this.getDevDependencies(workspaceName),
+            ];
             const peerDependencies = this.getPeerDependencies(workspaceName);
             const isReferencedDep = (name) => referencedDependencies?.has(name) && dependencies.includes(name);
             const isReferencedBin = (name) => referencedBinaries?.has(name) && installedBinaries?.has(name);
@@ -251,16 +252,17 @@ export class DependencyDeputy {
                 .forEach(identifier => configurationHints.add({ workspaceName, identifier, type: 'ignoreBinaries' }));
         }
         const installedBinaries = this.getInstalledBinaries(ROOT_WORKSPACE_NAME);
-        const dependencies = this.isStrict
-            ? this.getProductionDependencies(ROOT_WORKSPACE_NAME)
-            : [...this.getProductionDependencies(ROOT_WORKSPACE_NAME), ...this.getDevDependencies(ROOT_WORKSPACE_NAME)];
+        const dependencies = [
+            ...this.getProductionDependencies(ROOT_WORKSPACE_NAME),
+            ...this.getDevDependencies(ROOT_WORKSPACE_NAME),
+        ];
         const peerDependencies = this.getPeerDependencies(ROOT_WORKSPACE_NAME);
         Object.keys(rootIgnoreBinaries)
             .filter(key => IGNORED_GLOBAL_BINARIES.includes(key) || (rootIgnoreBinaries[key] !== 0 && installedBinaries?.has(key)))
             .forEach(identifier => configurationHints.add({ workspaceName: ROOT_WORKSPACE_NAME, identifier, type: 'ignoreBinaries' }));
         Object.keys(rootIgnoreDependencies)
             .filter(key => IGNORED_DEPENDENCIES.includes(key) ||
-            (rootIgnoreDependencies[key] !== 0 && !peerDependencies.includes(key) && dependencies.includes(key)))
+            (rootIgnoreDependencies[key] === 0 && !peerDependencies.includes(key) && !dependencies.includes(key)))
             .forEach(identifier => configurationHints.add({ workspaceName: ROOT_WORKSPACE_NAME, identifier, type: 'ignoreDependencies' }));
         return { configurationHints };
     }

package/dist/IssueCollector.d.ts

@@ -1,16 +1,21 @@
 import type { ConfigurationHint, Issue, Rules } from './types/issues.js';
+type Filters = Partial<{
+    dir: string;
+}>;
 type IssueCollectorOptions = {
     cwd: string;
     rules: Rules;
+    filters: Filters;
 };
 export declare class IssueCollector {
     private cwd;
     private rules;
+    private filters;
     private issues;
     private counters;
     private referencedFiles;
     private configurationHints;
-    constructor({ cwd, rules }: IssueCollectorOptions);
+    constructor({ cwd, rules, filters }: IssueCollectorOptions);
     addFileCounts({ processed, unused }: {
         processed: number;
         unused: number;

package/dist/IssueCollector.js

@@ -7,13 +7,15 @@ function objectInSet(set, obj) {
 export class IssueCollector {
     cwd;
     rules;
+    filters;
     issues = initIssues();
     counters = initCounters();
     referencedFiles = new Set();
     configurationHints = new Set();
-    constructor({ cwd, rules }) {
+    constructor({ cwd, rules, filters }) {
         this.cwd = cwd;
         this.rules = rules;
+        this.filters = filters;
     }
     addFileCounts({ processed, unused }) {
         this.counters.processed += processed;
@@ -21,14 +23,18 @@ export class IssueCollector {
     }
     addFilesIssues(filePaths) {
         filePaths.forEach(filePath => {
-            if (!this.referencedFiles.has(filePath)) {
-                this.issues.files.add(filePath);
-                this.counters.files++;
-                this.counters.processed++;
-            }
+            if (this.filters.dir && !filePath.startsWith(this.filters.dir + '/'))
+                return;
+            if (this.referencedFiles.has(filePath))
+                return;
+            this.issues.files.add(filePath);
+            this.counters.files++;
+            this.counters.processed++;
         });
     }
     addIssue(issue) {
+        if (this.filters.dir && !issue.filePath.startsWith(this.filters.dir + '/'))
+            return;
         const key = relative(this.cwd, issue.filePath);
         issue.severity = this.rules[issue.type];
         this.issues[issue.type][key] = this.issues[issue.type][key] ?? {};

package/dist/ProjectPrincipal.d.ts

@@ -53,7 +53,7 @@ export declare class ProjectPrincipal {
         };
         scripts: Set<string>;
     };
-    private resolveModule;
+    resolveModule(specifier: string, filePath?: string): ts.ResolvedModuleFull | undefined;
     getHasReferences(filePath: string, exportedItem: ExportItem): {
         external: boolean;
         internal: boolean;

package/dist/WorkspaceWorker.js

@@ -2,6 +2,7 @@ import * as npm from './manifest/index.js';
 import * as plugins from './plugins/index.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { _pureGlob, negate, hasProductionSuffix, hasNoProductionSuffix, prependDirToPattern } from './util/glob.js';
+import { FAKE_PATH } from './util/loader.js';
 import { get, getKeysByValue } from './util/object.js';
 import { join, toPosix } from './util/path.js';
 import { fromEntryPattern, fromProductionEntryPattern, isEntryPattern, isProductionEntryPattern, } from './util/protocols.js';
@@ -184,7 +185,7 @@ export class WorkspaceWorker {
                     if (patterns.length > 0 && configFilePaths.length === 0)
                         continue;
                     if (patterns.length === 0)
-                        configFilePaths.push('__FAKE__');
+                        configFilePaths.push(FAKE_PATH);
                     const pluginDependencies = new Set();
                     for (const configFilePath of configFilePaths) {
                         const dependencies = await plugin.findDependencies(configFilePath, {

package/dist/index.js

@@ -2,21 +2,17 @@ import micromatch from 'micromatch';
 import { _getDependenciesFromScripts } from './binaries/index.js';
 import { ConfigurationChief } from './ConfigurationChief.js';
 import { ConsoleStreamer } from './ConsoleStreamer.js';
-import { ROOT_WORKSPACE_NAME } from './constants.js';
 import { DependencyDeputy } from './DependencyDeputy.js';
 import { IssueCollector } from './IssueCollector.js';
 import { PrincipalFactory } from './PrincipalFactory.js';
 import { ProjectPrincipal } from './ProjectPrincipal.js';
 import { compact } from './util/array.js';
 import { debugLogObject, debugLogArray, debugLog } from './util/debug.js';
-import { LoaderError } from './util/errors.js';
-import { findFile } from './util/fs.js';
 import { _glob, negate } from './util/glob.js';
 import { getEntryPathFromManifest, getPackageNameFromFilePath, getPackageNameFromModuleSpecifier, } from './util/modules.js';
-import { dirname, isInNodeModules, join, isInternal, toAbsolute } from './util/path.js';
+import { dirname, isInNodeModules, join, isInternal } from './util/path.js';
 import { fromBinary, isBinary } from './util/protocols.js';
-import { _resolveSpecifier, _tryResolve } from './util/require.js';
-import { _require } from './util/require.js';
+import { _resolveSpecifier } from './util/require.js';
 import { loadTSConfig } from './util/tsconfig-loader.js';
 import { WorkspaceWorker } from './WorkspaceWorker.js';
 export const main = async (unresolvedConfiguration) => {
@@ -32,17 +28,18 @@ export const main = async (unresolvedConfiguration) => {
     const workspaces = chief.getWorkspaces();
     const report = chief.getIssueTypesToReport();
     const rules = chief.getRules();
+    const filters = chief.getFilters();
     const isReportDependencies = report.dependencies || report.unlisted || report.unresolved;
     const isReportValues = report.exports || report.nsExports || report.classMembers;
     const isReportTypes = report.types || report.nsTypes || report.enumMembers;
-    const collector = new IssueCollector({ cwd, rules });
+    const collector = new IssueCollector({ cwd, rules, filters });
     const enabledPluginsStore = new Map();
     deputy.addIgnored(chief.config.ignoreBinaries, chief.config.ignoreDependencies);
-    debugLogObject('Included workspaces', workspaces);
+    debugLogObject('Included workspaces', workspaces.map(w => w.pkgName));
+    debugLogObject('Included workspace configs', workspaces.map(w => ({ name: w.name, pkgName: w.pkgName, config: w.config, ancestors: w.ancestors })));
     const handleReferencedDependency = ({ specifier, containingFilePath, principal, workspace, }) => {
         if (isInternal(specifier)) {
-            const absSpecifier = toAbsolute(specifier, dirname(containingFilePath));
-            const filePath = _tryResolve(absSpecifier, containingFilePath);
+            const filePath = principal.resolveModule(specifier, containingFilePath)?.resolvedFileName;
             if (filePath) {
                 const ignorePatterns = workspace.config.ignore.map(pattern => join(dirname(containingFilePath), pattern));
                 const isIgnored = micromatch.isMatch(filePath, ignorePatterns);
@@ -68,7 +65,7 @@ export const main = async (unresolvedConfiguration) => {
                 if (!isHandled)
                     collector.addIssue({ type: 'unlisted', filePath: containingFilePath, symbol: specifier });
                 if (packageName && specifier !== packageName) {
-                    const otherWorkspace = chief.findWorkspaceByPackageName(packageName);
+                    const otherWorkspace = chief.availableWorkspaceManifests.find(w => w.manifest.name === packageName);
                     if (otherWorkspace) {
                         const filePath = _resolveSpecifier(otherWorkspace.dir, specifier);
                         if (filePath) {
@@ -83,14 +80,9 @@ export const main = async (unresolvedConfiguration) => {
         }
     };
     for (const workspace of workspaces) {
-        const { name, dir, config, ancestors, pkgName } = workspace;
+        const { name, dir, config, ancestors, pkgName, manifestPath, manifest } = workspace;
         const { paths, ignoreDependencies, ignoreBinaries } = config;
-        const isRoot = name === ROOT_WORKSPACE_NAME;
         streamer.cast(`Analyzing workspace (${name})...`);
-        const manifestPath = isRoot ? chief.manifestPath : findFile(dir, 'package.json');
-        const manifest = isRoot ? chief.manifest : manifestPath && _require(manifestPath);
-        if (!manifestPath || !manifest)
-            throw new LoaderError(`Unable to load package.json for ${name}`);
         deputy.addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, ignoreBinaries });
         const { compilerOptions, definitionPaths } = await loadTSConfig(join(dir, tsConfigFile ?? 'tsconfig.json'));
         const principal = factory.getPrincipal({ cwd: dir, paths, compilerOptions, compilers, pkgName });
@@ -195,7 +187,7 @@ export const main = async (unresolvedConfiguration) => {
                     exportedSymbols.set(filePath, exported);
                 for (const [specifierFilePath, importItems] of internal.entries()) {
                     const packageName = getPackageNameFromModuleSpecifier(importItems.specifier);
-                    if (packageName && chief.localWorkspaces.has(packageName)) {
+                    if (packageName && chief.availableWorkspacePkgNames.has(packageName)) {
                         external.add(packageName);
                         if (_principal === principal) {
                             const workspace = chief.findWorkspaceByFilePath(specifierFilePath);

package/dist/plugins/ava/index.js

@@ -7,19 +7,21 @@ export const ENABLERS = ['ava'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['ava.config.{js,cjs,mjs}', 'package.json'];
 export const ENTRY_FILE_PATTERNS = [
-    `test.{js,cjs,mjs}`,
-    `{src,source}/test.{js,cjs,mjs}`,
-    `**/__tests__/**/*.{js,cjs,mjs}`,
-    `**/*.spec.{js,cjs,mjs}`,
-    `**/*.test.{js,cjs,mjs}`,
-    `**/test-*.{js,cjs,mjs}`,
-    `**/test/**/*.{js,cjs,mjs}`,
-    `**/tests/**/*.{js,cjs,mjs}`,
+    `test.{js,cjs,mjs,ts}`,
+    `{src,source}/test.{js,cjs,mjs,ts}`,
+    `**/__tests__/**/*.{js,cjs,mjs,ts}`,
+    `**/*.spec.{js,cjs,mjs,ts}`,
+    `**/*.test.{js,cjs,mjs,ts}`,
+    `**/test-*.{js,cjs,mjs,ts}`,
+    `**/test/**/*.{js,cjs,mjs,ts}`,
+    `**/tests/**/*.{js,cjs,mjs,ts}`,
     '!**/__tests__/**/__{helper,fixture}?(s)__/**/*',
     '!**/test?(s)/**/{helper,fixture}?(s)/**/*',
 ];
 const findAvaDependencies = async (configFilePath, { cwd, manifest, isProduction }) => {
-    const config = configFilePath.endsWith('package.json') ? manifest.ava : await load(configFilePath);
+    let config = configFilePath.endsWith('package.json') ? manifest.ava : await load(configFilePath);
+    if (typeof config === 'function')
+        config = config();
     const entryPatterns = (config?.files ?? ENTRY_FILE_PATTERNS).map(toEntryPattern);
     if (isProduction)
         return entryPatterns;

package/dist/plugins/ava/types.d.ts

@@ -1,5 +1,8 @@
-export type PluginConfig = {
+type Config = {
     files?: string[];
     require?: string[];
     nodeArguments?: string[];
+    extensions?: string[];
 };
+export type AvaConfig = Config | (() => Config);
+export {};

package/dist/typescript/resolveModuleNames.js

@@ -2,7 +2,19 @@ import { existsSync } from 'node:fs';
 import ts from 'typescript';
 import { sanitizeSpecifier } from '../util/modules.js';
 import { dirname, extname, isInternal, join } from '../util/path.js';
+import { isDeclarationFileExtension } from './ast-helpers.js';
 import { ensureRealFilePath, isVirtualFilePath } from './utils.js';
+const simpleResolver = (name, containingFile) => {
+    const resolvedFileName = join(dirname(containingFile), name);
+    if (existsSync(resolvedFileName)) {
+        return {
+            resolvedFileName,
+            extension: extname(resolvedFileName),
+            isExternalLibraryImport: false,
+            resolvedUsingTsExtension: false,
+        };
+    }
+};
 export function createCustomModuleResolver(customSys, compilerOptions, virtualFileExtensions) {
     function resolveModuleNames(moduleNames, containingFile) {
         return moduleNames.map(moduleName => resolveModuleName(moduleName, containingFile));
@@ -13,17 +25,18 @@ export function createCustomModuleResolver(customSys, compilerOptions, virtualFi
         if (!tsResolvedModule) {
             const extension = extname(sanitizedSpecifier);
             if (extension && isInternal(sanitizedSpecifier) && !virtualFileExtensions.includes(extension)) {
-                const resolvedFileName = join(dirname(containingFile), sanitizedSpecifier);
-                if (existsSync(resolvedFileName)) {
-                    return {
-                        resolvedFileName,
-                        extension,
-                        isExternalLibraryImport: false,
-                        resolvedUsingTsExtension: false,
-                    };
-                }
+                const module = simpleResolver(sanitizedSpecifier, containingFile);
+                if (module)
+                    return module;
             }
         }
+        if (tsResolvedModule &&
+            isDeclarationFileExtension(tsResolvedModule?.extension) &&
+            isInternal(tsResolvedModule.resolvedFileName)) {
+            const module = simpleResolver(sanitizedSpecifier, containingFile);
+            if (module)
+                return module;
+        }
         if (virtualFileExtensions.length === 0)
             return tsResolvedModule;
         if (tsResolvedModule && !isVirtualFilePath(tsResolvedModule.resolvedFileName, virtualFileExtensions)) {

package/dist/util/loader.d.ts

@@ -1 +1,2 @@
+export declare const FAKE_PATH = "__FAKE__";
 export declare const _load: (filePath: string) => Promise<any>;

package/dist/util/loader.js

@@ -4,7 +4,10 @@ import { loadJSON, loadYAML, loadFile, parseJSON, parseYAML } from './fs.js';
 import { extname } from './path.js';
 import { timerify } from './Performance.js';
 import { jiti } from './register.js';
+export const FAKE_PATH = '__FAKE__';
 const load = async (filePath) => {
+    if (filePath === FAKE_PATH)
+        return;
     try {
         const ext = extname(filePath);
         if (/rc$/.test(filePath)) {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.32.2";
+export declare const version = "2.32.4";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.32.2';
+export const version = '2.32.4';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "2.32.2",
+  "version": "2.32.4",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",
@@ -19,12 +19,12 @@
   "scripts": {
     "knip": "node ./dist/cli.js",
     "knip:production": "node ./dist/cli.js --production --strict --ignore-internal",
-    "lint": "eslint scripts src tests",
-    "lint:fix": "eslint scripts src tests --fix",
-    "format": "prettier scripts src tests schema.json --with-node-modules --write --config .prettierrc",
-    "pretest": "node rmdir.js tmp && swc src -d tmp/src && swc tests -d tmp/tests",
+    "lint": "eslint scripts src test",
+    "lint:fix": "eslint scripts src test --fix",
+    "format": "prettier scripts src test schema.json --with-node-modules --write --config .prettierrc",
+    "pretest": "node rmdir.js tmp && swc src -d tmp/src && swc test -d tmp/test",
     "test": "node --no-warnings --test tmp",
-    "coverage": "c8 --reporter html node --no-warnings --loader tsx --test tests/*.test.ts tests/*/*.test.ts",
+    "coverage": "c8 --reporter html node --no-warnings --loader tsx --test test/*.test.ts test/*/*.test.ts",
     "watch": "rm $(which knip); npm link && tsc --watch",
     "prebuild": "node rmdir.js dist",
     "build": "tsc",
@@ -44,6 +44,8 @@
   "dependencies": {
     "@ericcornelissen/bash-parser": "^0.5.2",
     "@npmcli/map-workspaces": "^3.0.4",
+    "@pnpm/logger": "5.0.0",
+    "@pnpm/workspace.pkgs-graph": "2.0.6",
     "@snyk/github-codeowners": "^1.1.0",
     "chalk": "^5.2.0",
     "easy-table": "^1.2.0",