knip 5.61.2 → 5.61.3

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/graph/build.js

@@ -1,15 +1,16 @@
 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 { 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, }) {
@@ -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/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/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/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/version.d.ts

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

package/dist/version.js

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

package/package.json

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