knip 5.61.2 → 5.62.0

package/dist/ConfigurationChief.js

@@ -16,7 +16,7 @@ import { defaultRules } from './util/issue-initializers.js';
 import { _load } from './util/loader.js';
 import mapWorkspaces from './util/map-workspaces.js';
 import { getKeysByValue } from './util/object.js';
-import { join, relative } from './util/path.js';
+import { isAbsolute, join, relative } from './util/path.js';
 import { normalizePluginConfig } from './util/plugin.js';
 import { toRegexOrString } from './util/regex.js';
 import { ELLIPSIS } from './util/string.js';
@@ -100,7 +100,7 @@ export class ConfigurationChief {
             this.manifest.workspaces = pnpmWorkspaces;
         }
         for (const configPath of rawConfigArg ? [rawConfigArg] : KNIP_CONFIG_LOCATIONS) {
-            this.resolvedConfigFilePath = findFile(this.cwd, configPath);
+            this.resolvedConfigFilePath = isAbsolute(configPath) ? configPath : findFile(this.cwd, configPath);
             if (this.resolvedConfigFilePath)
                 break;
         }

package/dist/DependencyDeputy.js

@@ -1,5 +1,5 @@
 import { isBuiltin } from 'node:module';
-import { PackageJsonPeeker } from './PackageJsonPeeker.js';
+import { PackagePeeker } from './PackagePeeker.js';
 import { DT_SCOPE, IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES, IGNORED_RUNTIME_DEPENDENCIES, IGNORE_DEFINITELY_TYPED, ROOT_WORKSPACE_NAME, } from './constants.js';
 import { getDependencyMetaData } from './manifest/index.js';
 import { getDefinitelyTypedFor, getPackageFromDefinitelyTyped, getPackageNameFromModuleSpecifier, isDefinitelyTyped, } from './util/modules.js';
@@ -176,12 +176,12 @@ export class DependencyDeputy {
         for (const [workspace, { manifestPath: filePath, manifestStr }] of this._manifests.entries()) {
             const referencedDependencies = this.referencedDependencies.get(workspace);
             const hasTypesIncluded = this.getHasTypesIncluded(workspace);
-            const peeker = new PackageJsonPeeker(manifestStr);
-            const peerDepRecs = {};
+            const peeker = new PackagePeeker(manifestStr);
+            const peerDepCount = {};
             const isReferencedDependency = (dependency, isPeerDep) => {
                 if (referencedDependencies?.has(dependency))
                     return true;
-                if (isPeerDep && peerDepRecs[dependency])
+                if (isPeerDep && peerDepCount[dependency])
                     return false;
                 const [scope, typedDependency] = dependency.split('/');
                 if (scope === DT_SCOPE) {
@@ -202,10 +202,10 @@ export class DependencyDeputy {
                 }
                 const hostDependencies = this.getHostDependenciesFor(workspace, dependency);
                 for (const { name } of hostDependencies) {
-                    if (!peerDepRecs[name])
-                        peerDepRecs[name] = 1;
+                    if (!peerDepCount[name])
+                        peerDepCount[name] = 1;
                     else
-                        peerDepRecs[name]++;
+                        peerDepCount[name]++;
                 }
                 return hostDependencies.some(hostDependency => (isPeerDep === false || !hostDependency.isPeerOptional) && isReferencedDependency(hostDependency.name, true));
             };

package/dist/{PackageJsonPeeker.d.ts → PackagePeeker.d.ts}

@@ -1,4 +1,4 @@
-export declare class PackageJsonPeeker {
+export declare class PackagePeeker {
     private manifestStr;
     private lines;
     private sections;

package/dist/{PackageJsonPeeker.js → PackagePeeker.js}

@@ -1,4 +1,4 @@
-export class PackageJsonPeeker {
+export class PackagePeeker {
     manifestStr;
     lines = [];
     sections = {};

package/dist/ProjectPrincipal.d.ts

@@ -50,7 +50,7 @@ export declare class ProjectPrincipal {
     getUsedResolvedFiles(): string[];
     private getProgramSourceFiles;
     getUnreferencedFiles(): string[];
-    analyzeSourceFile(filePath: string, options: Omit<GetImportsAndExportsOptions, 'skipExports'>, isGitIgnored: (filePath: string) => boolean, isInternalWorkspace: (packageName: string) => boolean, getPrincipalByFilePath: (filePath: string) => undefined | ProjectPrincipal): FileNode;
+    analyzeSourceFile(filePath: string, options: Omit<GetImportsAndExportsOptions, 'skipExports'>): FileNode;
     invalidateFile(filePath: string): void;
     findUnusedMembers(filePath: string, members: ExportMember[]): ExportMember[];
     hasExternalReferences(filePath: string, exportedItem: Export): boolean;

package/dist/ProjectPrincipal.js

@@ -1,14 +1,13 @@
 import ts from 'typescript';
 import { CacheConsultant } from './CacheConsultant.js';
 import { getCompilerExtensions } from './compilers/index.js';
-import { ANONYMOUS, DEFAULT_EXTENSIONS, FOREIGN_FILE_EXTENSIONS, PUBLIC_TAG } from './constants.js';
+import { ANONYMOUS, DEFAULT_EXTENSIONS, PUBLIC_TAG } from './constants.js';
 import { SourceFileManager } from './typescript/SourceFileManager.js';
 import { createHosts } from './typescript/create-hosts.js';
 import { _getImportsAndExports } from './typescript/get-imports-and-exports.js';
 import { timerify } from './util/Performance.js';
 import { compact } from './util/array.js';
-import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpecifier } from './util/modules.js';
-import { dirname, extname, isInNodeModules, join, toAbsolute } from './util/path.js';
+import { extname, isInNodeModules, toAbsolute } from './util/path.js';
 const baseCompilerOptions = {
     allowJs: true,
     allowSyntheticDefaultImports: true,
@@ -156,7 +155,7 @@ export class ProjectPrincipal {
         const sourceFiles = this.getProgramSourceFiles();
         return Array.from(this.projectPaths).filter(filePath => !sourceFiles.has(filePath));
     }
-    analyzeSourceFile(filePath, options, isGitIgnored, isInternalWorkspace, getPrincipalByFilePath) {
+    analyzeSourceFile(filePath, options) {
         const fd = this.cache.getFileDescriptor(filePath);
         if (!fd.changed && fd.meta?.data)
             return fd.meta.data;
@@ -168,43 +167,7 @@ export class ProjectPrincipal {
             throw new Error(`Unable to find ${filePath}`);
         const skipExports = this.skipExportsAnalysis.has(filePath);
         const resolve = (specifier) => this.backend.resolveModuleNames([specifier], sourceFile.fileName)[0];
-        const { imports, ...rest } = _getImportsAndExports(sourceFile, resolve, typeChecker, { ...options, skipExports });
-        const { internal, resolved, specifiers, unresolved, external } = imports;
-        const unresolvedImports = new Set();
-        for (const [specifier, specifierFilePath] of specifiers) {
-            const packageName = getPackageNameFromModuleSpecifier(specifier);
-            if (packageName && isInternalWorkspace(packageName)) {
-                external.add(packageName);
-                const principal = getPrincipalByFilePath(specifierFilePath);
-                if (principal && !isGitIgnored(specifierFilePath))
-                    principal.addNonEntryPath(specifierFilePath);
-            }
-        }
-        for (const filePath of resolved) {
-            const isIgnored = isGitIgnored(filePath);
-            if (!isIgnored)
-                this.addEntryPath(filePath, { skipExportsAnalysis: true });
-        }
-        for (const unresolvedImport of unresolved) {
-            const { specifier } = unresolvedImport;
-            if (specifier.startsWith('http'))
-                continue;
-            const sanitizedSpecifier = sanitizeSpecifier(specifier);
-            if (isStartsLikePackageName(sanitizedSpecifier)) {
-                external.add(sanitizedSpecifier);
-            }
-            else {
-                const isIgnored = isGitIgnored(join(dirname(filePath), sanitizedSpecifier));
-                if (!isIgnored) {
-                    const ext = extname(sanitizedSpecifier);
-                    const hasIgnoredExtension = FOREIGN_FILE_EXTENSIONS.has(ext);
-                    if (!ext || (ext !== '.json' && !hasIgnoredExtension)) {
-                        unresolvedImports.add(unresolvedImport);
-                    }
-                }
-            }
-        }
-        return { imports: { internal, unresolved: unresolvedImports, external }, ...rest };
+        return _getImportsAndExports(sourceFile, resolve, typeChecker, { ...options, skipExports });
     }
     invalidateFile(filePath) {
         this.backend.fileManager.snapshotCache.delete(filePath);

package/dist/WorkspaceWorker.d.ts

@@ -29,6 +29,7 @@ type WorkspaceManagerOptions = {
 type CacheItem = {
     resolveConfig?: Input[];
     resolveFromAST?: Input[];
+    configFile?: Input;
 };
 export declare class WorkspaceWorker {
     name: string;

package/dist/WorkspaceWorker.js

@@ -262,6 +262,8 @@ export class WorkspaceWorker {
                     if (data.resolveFromAST)
                         for (const id of data.resolveFromAST)
                             addInput(id, configFilePath);
+                    if (data.configFile)
+                        addInput(data.configFile);
                     continue;
                 }
                 const resolveOpts = {
@@ -301,15 +303,17 @@ export class WorkspaceWorker {
                         cache.resolveFromAST = inputs;
                     }
                 }
-                if (basename(configFilePath) !== 'package.json') {
+                if (!isManifest) {
                     addInput(toEntry(configFilePath));
                     addInput(toConfig(pluginName, configFilePath));
+                    cache.configFile = toEntry(configFilePath);
+                    if (fd?.changed && fd.meta && !seen.get(key)?.has(configFilePath)) {
+                        fd.meta.data = cache;
+                    }
                     if (!seen.has(key))
                         seen.set(key, new Set());
                     seen.get(key)?.add(configFilePath);
                 }
-                if (!isManifest && fd?.changed && fd.meta)
-                    fd.meta.data = cache;
             }
             if (plugin.resolve) {
                 const dependencies = (await plugin.resolve(options)) ?? [];

package/dist/binaries/package-manager/bun.js

@@ -3,7 +3,21 @@ import { isFile } from '../../util/fs.js';
 import { toEntry } from '../../util/input.js';
 import { isAbsolute, join } from '../../util/path.js';
 import { resolveX } from './bunx.js';
-const commands = ['add', 'create', 'init', 'install', 'link', 'pm', 'remove', 'run', 'test', 'update', 'upgrade', 'x'];
+const commands = [
+    'add',
+    'audit',
+    'create',
+    'init',
+    'install',
+    'link',
+    'pm',
+    'remove',
+    'run',
+    'test',
+    'update',
+    'upgrade',
+    'x',
+];
 export const resolve = (_binary, args, options) => {
     const parsed = parseArgs(args, { string: ['cwd'] });
     const [command, script] = parsed._;

package/dist/graph/build.js

@@ -1,17 +1,18 @@
 import { WorkspaceWorker } from '../WorkspaceWorker.js';
 import { _getInputsFromScripts } from '../binaries/index.js';
 import { getCompilerExtensions, getIncludedCompilers } from '../compilers/index.js';
-import { DEFAULT_EXTENSIONS } from '../constants.js';
+import { DEFAULT_EXTENSIONS, FOREIGN_FILE_EXTENSIONS } from '../constants.js';
 import { perfObserver } from '../util/Performance.js';
 import { debugLog, debugLogArray } from '../util/debug.js';
 import { getReferencedInputsHandler } from '../util/get-referenced-inputs.js';
 import { _glob, negate } from '../util/glob.js';
 import { isAlias, isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isIgnore, isProductionEntry, isProject, toProductionEntry, } from '../util/input.js';
+import { loadTSConfig } from '../util/load-tsconfig.js';
 import { getOrCreateFileNode, updateImportMap } from '../util/module-graph.js';
+import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
 import { getEntryPathsFromManifest } from '../util/package-json.js';
-import { dirname, isAbsolute, join, relative, toRelative } from '../util/path.js';
+import { dirname, extname, isAbsolute, join, relative, toRelative } from '../util/path.js';
 import { augmentWorkspace, getToSourcePathHandler, getToSourcePathsHandler } from '../util/to-source-path.js';
-import { loadTSConfig } from '../util/tsconfig-loader.js';
 export async function build({ cacheLocation, chief, collector, cwd, deputy, factory, gitignore, isCache, isFixExports, isFixTypes, isGitIgnored, isIsolateWorkspaces, isProduction, isSkipLibs, isStrict, isWatch, report, streamer, tags, tsConfigFile, workspaces, }) {
     const configFilesMap = new Map();
     const enabledPluginsStore = new Map();
@@ -250,37 +251,68 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
         analyzedFiles.add(filePath);
         const workspace = chief.findWorkspaceByFilePath(filePath);
         if (workspace) {
-            const { imports, exports, duplicates, scripts, traceRefs } = principal.analyzeSourceFile(filePath, {
+            const file = principal.analyzeSourceFile(filePath, {
                 skipTypeOnly: isStrict,
                 isFixExports,
                 isFixTypes,
                 ignoreExportsUsedInFile: chief.config.ignoreExportsUsedInFile,
                 isReportClassMembers,
                 tags,
-            }, isGitIgnored, isInternalWorkspace, getPrincipalByFilePath);
-            const node = getOrCreateFileNode(graph, filePath);
-            node.imports = imports;
-            node.exports = exports;
-            node.duplicates = duplicates;
-            node.scripts = scripts;
-            node.traceRefs = traceRefs;
-            updateImportMap(node, imports.internal, graph);
-            node.internalImportCache = imports.internal;
-            graph.set(filePath, node);
-            if (scripts && scripts.size > 0) {
+            });
+            const _unresolved = new Set();
+            for (const unresolvedImport of file.imports.unresolved) {
+                const { specifier } = unresolvedImport;
+                if (specifier.startsWith('http'))
+                    continue;
+                const sanitizedSpecifier = sanitizeSpecifier(specifier);
+                if (isStartsLikePackageName(sanitizedSpecifier)) {
+                    file.imports.external.add(sanitizedSpecifier);
+                }
+                else {
+                    const isIgnored = isGitIgnored(join(dirname(filePath), sanitizedSpecifier));
+                    if (!isIgnored) {
+                        const ext = extname(sanitizedSpecifier);
+                        const hasIgnoredExtension = FOREIGN_FILE_EXTENSIONS.has(ext);
+                        if (!ext || (ext !== '.json' && !hasIgnoredExtension))
+                            _unresolved.add(unresolvedImport);
+                    }
+                }
+            }
+            for (const filePath of file.imports.resolved) {
+                const isIgnored = isGitIgnored(filePath);
+                if (!isIgnored)
+                    principal.addEntryPath(filePath, { skipExportsAnalysis: true });
+            }
+            for (const [specifier, specifierFilePath] of file.imports.specifiers) {
+                const packageName = getPackageNameFromModuleSpecifier(specifier);
+                if (packageName && isInternalWorkspace(packageName)) {
+                    file.imports.external.add(packageName);
+                    const principal = getPrincipalByFilePath(specifierFilePath);
+                    if (principal && !isGitIgnored(specifierFilePath)) {
+                        principal.addNonEntryPath(specifierFilePath);
+                    }
+                }
+            }
+            if (file.scripts && file.scripts.size > 0) {
                 const dependencies = deputy.getDependencies(workspace.name);
                 const manifestScriptNames = new Set(Object.keys(chief.getManifestForWorkspace(workspace.name)?.scripts ?? {}));
                 const dir = dirname(filePath);
                 const options = { cwd: dir, rootCwd: cwd, containingFilePath: filePath, dependencies, manifestScriptNames };
-                const inputs = _getInputsFromScripts(scripts, options);
+                const inputs = _getInputsFromScripts(file.scripts, options);
                 for (const input of inputs) {
                     input.containingFilePath ??= filePath;
                     input.dir ??= dir;
                     const specifierFilePath = getReferencedInternalFilePath(input, workspace);
                     if (specifierFilePath)
-                        analyzeSourceFile(specifierFilePath, principal);
+                        principal.addEntryPath(specifierFilePath, { skipExportsAnalysis: true });
                 }
             }
+            const node = getOrCreateFileNode(graph, filePath);
+            file.imports.unresolved = _unresolved;
+            Object.assign(node, file);
+            updateImportMap(node, file.imports.internal, graph);
+            node.internalImportCache = file.imports.internal;
+            graph.set(filePath, node);
         }
     };
     for (let i = 0; i < principals.length; ++i) {

package/dist/plugins/angular/index.js

@@ -18,7 +18,7 @@ const resolveConfig = async (config, options) => {
         for (const [targetName, target] of Object.entries(project.architect)) {
             const { options: opts, configurations: configs } = target;
             const [packageName] = typeof target.builder === 'string' ? target.builder.split(':') : [];
-            if (typeof packageName === 'string')
+            if (packageName)
                 inputs.add(toDependency(packageName));
             if (opts) {
                 if ('tsConfig' in opts && typeof opts.tsConfig === 'string') {
@@ -55,7 +55,7 @@ const resolveConfig = async (config, options) => {
                     }));
                 }
             }
-            if (target.builder === '@angular-devkit/build-angular:karma' && opts) {
+            if (target.builder && isAngularBuilderRefWithName({ builderRef: target.builder, name: 'karma' }) && opts) {
                 const karmaBuilderOptions = opts;
                 const testFilePatterns = karmaBuilderOptions.include ?? ['**/*.spec.ts'];
                 for (const testFilePattern of testFilePatterns) {
@@ -103,6 +103,10 @@ const entriesByOption = (opts) => new Map(Object.entries({
         ? [opts.ssr.entry]
         : [],
 }));
+const isAngularBuilderRefWithName = ({ builderRef, name }) => {
+    const [pkg, builderName] = builderRef.split(':');
+    return (pkg === '@angular-devkit/build-angular' || pkg === '@angular/build') && builderName === name;
+};
 const PRODUCTION_CONFIG_NAME = 'production';
 const BUILD_TARGET_NAME = 'build';
 export default {

package/dist/plugins/astro/index.js

@@ -14,14 +14,10 @@ const production = [
 ];
 const resolveFromAST = sourceFile => {
     const srcDir = getSrcDir(sourceFile);
+    const setSrcDir = (entry) => entry.replace(/^`src\//, `${srcDir}/`);
     return [
-        ...[`${srcDir}/content/config.ts`, `${srcDir}/content.config.ts`].map(path => toEntry(path)),
-        ...[
-            `${srcDir}/pages/**/*.{astro,mdx,js,ts}`,
-            `${srcDir}/content/**/*.mdx`,
-            `${srcDir}/middleware.{js,ts}`,
-            `${srcDir}/actions/index.{js,ts}`,
-        ].map(path => toProductionEntry(path)),
+        ...entry.map(setSrcDir).map(path => toEntry(path)),
+        ...production.map(setSrcDir).map(path => toProductionEntry(path)),
     ];
 };
 const resolve = options => {

package/dist/plugins/astro/resolveFromAST.js

@@ -20,6 +20,5 @@ export const getSrcDir = (sourceFile) => {
         });
         return result;
     }
-    const foundValue = visit(sourceFile);
-    return foundValue ?? srcDir;
+    return visit(sourceFile) ?? srcDir;
 };

package/dist/plugins/biome/index.js

@@ -1,14 +1,22 @@
+import { arrayify } from '../../util/array.js';
 import { toConfig } from '../../util/input.js';
+import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Biome';
 const enablers = ['@biomejs/biome'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['biome.json', 'biome.jsonc'];
+const isRootConfigReference = (specifier) => specifier === '//';
 const resolveExtends = (extendsArray, options) => {
-    return extendsArray.map(specifier => toConfig('biome', specifier, { containingFilePath: options.configFilePath }));
+    return extendsArray.map(specifier => {
+        if (isRootConfigReference(specifier)) {
+            return toConfig('biome', join(options.rootCwd, 'biome'), { containingFilePath: options.configFilePath });
+        }
+        return toConfig('biome', specifier, { containingFilePath: options.configFilePath });
+    });
 };
 const resolveConfig = (config, options) => {
-    return [...resolveExtends(config.extends || [], options)];
+    return [...resolveExtends(arrayify(config.extends), options)];
 };
 export default {
     title,

package/dist/plugins/eslint/helpers.js

@@ -8,7 +8,8 @@ export const getInputs = (config, options) => {
     if (extname(configFileName) === '.json' || !/eslint\.config/.test(configFileName)) {
         return getInputsDeprecated(config, options);
     }
-    const dependencies = config.flatMap(config => config.settings ? getDependenciesFromSettings(config.settings).filter(id => id !== '@typescript-eslint/parser') : []);
+    const dependencies = config.flatMap(config => config.settings ? getDependenciesFromSettings(config.settings) : []);
+    dependencies.push('eslint-import-resolver-typescript');
     return compact(dependencies).map(id => toDeferResolve(id, { optional: true }));
 };
 const getInputsDeprecated = (config, options) => {

package/dist/plugins/karma/index.js

@@ -1,5 +1,5 @@
 import { toEntry } from '../../util/input.js';
-import { join } from '../../util/path.js';
+import { isAbsolute, join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { configFiles, inputsFromFrameworks, inputsFromPlugins, loadConfig } from './helpers.js';
 const title = 'Karma';
@@ -19,12 +19,14 @@ const resolveConfig = async (localConfig, options) => {
     if (config.files) {
         for (const fileOrPatternObj of config.files) {
             const fileOrPattern = typeof fileOrPatternObj === 'string' ? fileOrPatternObj : fileOrPatternObj.pattern;
-            inputs.add(toEntry(join(options.configFileDir, basePath, fileOrPattern)));
+            const absPath = isAbsolute(fileOrPattern) ? fileOrPattern : join(options.configFileDir, basePath, fileOrPattern);
+            inputs.add(toEntry(absPath));
         }
     }
     if (config.exclude) {
         for (const fileOrPattern of config.exclude) {
-            inputs.add(toEntry(`!${join(options.configFileDir, basePath, fileOrPattern)}`));
+            const absPath = isAbsolute(fileOrPattern) ? fileOrPattern : join(options.configFileDir, basePath, fileOrPattern);
+            inputs.add(toEntry(`!${absPath}`));
         }
     }
     return Array.from(inputs);

package/dist/plugins/postcss/index.js

@@ -7,7 +7,7 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = [
     'package.json',
     'postcss.config.json',
-    ...toLilconfig('postcss', { configDir: false, additionalExtensions: ['ts', 'mts', 'cts', 'yaml', 'yml'] }),
+    ...toLilconfig('postcss', { configDir: false, additionalExtensions: ['mts', 'cts', 'yaml', 'yml'] }),
 ];
 const resolveConfig = config => {
     const plugins = config.plugins

package/dist/plugins/size-limit/index.js

@@ -6,7 +6,7 @@ const enablers = ['size-limit'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = [
     'package.json',
-    ...toLilconfig('size-limit', { configDir: false, additionalExtensions: ['ts', 'mts', 'cts'], rcSuffix: '' }),
+    ...toLilconfig('size-limit', { configDir: false, additionalExtensions: ['mts', 'cts'], rcSuffix: '' }),
 ];
 const resolve = options => {
     const allDeps = [

package/dist/plugins/vitest/index.js

@@ -1,5 +1,6 @@
 import { DEFAULT_EXTENSIONS } from '../../constants.js';
-import { toAlias, toDeferResolve, toDependency, toEntry } from '../../util/input.js';
+import { _glob } from '../../util/glob.js';
+import { toAlias, toConfig, toDeferResolve, toDependency, toEntry } from '../../util/input.js';
 import { join, toPosix } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getEnvPackageName, getExternalReporters } from './helpers.js';
@@ -28,11 +29,20 @@ const findConfigDependencies = (localConfig, options) => {
             workspaceDependencies.push(...findConfigDependencies(workspaceConfig, options));
         }
     }
+    const projectsDependencies = [];
+    if (testConfig.projects !== undefined) {
+        for (const projectConfig of testConfig.projects) {
+            if (typeof projectConfig !== 'string') {
+                projectsDependencies.push(...findConfigDependencies(projectConfig, options));
+            }
+        }
+    }
     return [
         ...[...environments, ...reporters, ...coverage].map(id => toDependency(id)),
         ...setupFiles,
         ...globalSetup,
         ...workspaceDependencies,
+        ...projectsDependencies,
     ];
 };
 const getConfigs = async (localConfig) => {
@@ -44,11 +54,25 @@ const getConfigs = async (localConfig) => {
                     for (const mode of ['development', 'production']) {
                         const cfg = await config({ command, mode, ssrBuild: undefined });
                         configs.push(cfg);
+                        if (cfg.test?.projects) {
+                            for (const project of cfg.test.projects) {
+                                if (typeof project !== 'string') {
+                                    configs.push(project);
+                                }
+                            }
+                        }
                     }
                 }
             }
             else {
                 configs.push(config);
+                if (config.test?.projects) {
+                    for (const project of config.test.projects) {
+                        if (typeof project !== 'string') {
+                            configs.push(project);
+                        }
+                    }
+                }
             }
         }
     }
@@ -58,6 +82,22 @@ export const resolveConfig = async (localConfig, options) => {
     const inputs = new Set();
     inputs.add(toEntry(join(options.cwd, 'src/vite-env.d.ts')));
     const configs = await getConfigs(localConfig);
+    for (const cfg of configs) {
+        if (cfg.test?.projects) {
+            for (const project of cfg.test.projects) {
+                if (typeof project === 'string') {
+                    const projectFiles = await _glob({
+                        cwd: options.cwd,
+                        patterns: [project],
+                        gitignore: false,
+                    });
+                    for (const projectFile of projectFiles) {
+                        inputs.add(toConfig('vitest', projectFile, { containingFilePath: options.configFilePath }));
+                    }
+                }
+            }
+        }
+    }
     const addStar = (value) => (value.endsWith('*') ? value : join(value, '*').replace(/\/\*\*$/, '/*'));
     const addAliases = (aliasOptions) => {
         for (const [alias, value] of Object.entries(aliasOptions)) {

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

@@ -23,6 +23,11 @@ interface VitestConfig {
                 workspace: never;
             };
         })[];
+        projects?: (string | (ViteConfig & {
+            test: VitestConfig['test'] & {
+                projects: never;
+            };
+        }))[];
         alias?: AliasOptions;
     };
 }

package/dist/types/module-graph.d.ts

@@ -55,6 +55,8 @@ export type FileNode = {
         internal: ImportMap;
         external: Set<string>;
         unresolved: Set<UnresolvedImport>;
+        resolved: Set<FilePath>;
+        specifiers: Set<[string, FilePath]>;
     };
     exports: ExportMap;
     duplicates: Iterable<Array<IssueSymbol>>;

package/dist/typescript/ast-helpers.js

@@ -149,7 +149,7 @@ const getMemberStringLiterals = (typeChecker, node) => {
             return type.types.map(type => type.value);
     }
     if (ts.isPropertyAccessExpression(node)) {
-        return [node.name.escapedText];
+        return [node.name.getText()];
     }
 };
 export const getAccessMembers = (typeChecker, node) => {

package/dist/typescript/get-imports-and-exports.d.ts

@@ -1,18 +1,5 @@
 import ts from 'typescript';
 import type { GetImportsAndExportsOptions } from '../types/config.js';
-import type { IssueSymbol } from '../types/issues.js';
-import type { ExportMap, ImportMap, UnresolvedImport } from '../types/module-graph.js';
+import type { FileNode } from '../types/module-graph.js';
 import type { BoundSourceFile } from './SourceFile.js';
-export declare const _getImportsAndExports: (sourceFile: BoundSourceFile, resolveModule: (specifier: string) => ts.ResolvedModuleFull | undefined, typeChecker: ts.TypeChecker, options: GetImportsAndExportsOptions) => {
-    imports: {
-        internal: ImportMap;
-        external: Set<string>;
-        resolved: Set<string>;
-        specifiers: Set<[string, string]>;
-        unresolved: Set<UnresolvedImport>;
-    };
-    exports: ExportMap;
-    duplicates: IssueSymbol[][];
-    scripts: Set<string>;
-    traceRefs: Set<string>;
-};
+export declare const _getImportsAndExports: (sourceFile: BoundSourceFile, resolveModule: (specifier: string) => ts.ResolvedModuleFull | undefined, typeChecker: ts.TypeChecker, options: GetImportsAndExportsOptions) => FileNode;

package/dist/util/module-graph.js

@@ -35,6 +35,8 @@ const createFileNode = () => ({
         internal: new Map(),
         external: new Set(),
         unresolved: new Set(),
+        resolved: new Set(),
+        specifiers: new Set(),
     },
     exports: new Map(),
     duplicates: new Set(),

package/dist/util/plugin-config.js

@@ -23,7 +23,7 @@ const toConfigMap = (defaultExtensions, builderConfig) => (moduleName, options)
     return [...baseFiles, rcFiles, ...configFiles, ...configDirFiles];
 };
 export const toCosmiconfig = toConfigMap(['json', 'yaml', 'yml', 'js', 'ts', 'cjs', 'mjs'], { configDir: true });
-export const toLilconfig = toConfigMap(['json', 'js', 'cjs', 'mjs'], { configDir: true });
+export const toLilconfig = toConfigMap(['json', 'ts', 'js', 'cjs', 'mjs'], { configDir: true });
 export const toUnconfig = toConfigMap(['json', 'ts', 'mts', 'cts', 'js', 'mjs', 'cjs'], {
     configDir: false,
     rcPrefix: '',

package/dist/util/resolve.js

@@ -16,6 +16,6 @@ const createSyncResolver = (extensions) => {
         catch (_error) { }
     };
 };
-const resolveSync = createSyncResolver([...DEFAULT_EXTENSIONS, '.json']);
+const resolveSync = createSyncResolver([...DEFAULT_EXTENSIONS, '.json', '.jsonc']);
 export const _resolveSync = timerify(resolveSync);
 export const _createSyncResolver = extensions => timerify(createSyncResolver(extensions));

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.61.2";
+export declare const version = "5.62.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.61.2';
+export const version = '5.62.0';

package/package.json

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