knip 5.74.0 → 5.75.1

package/README.md

@@ -21,6 +21,7 @@ performance, less maintenance and easier refactorings.
 - GitHub repo: [webpro-nl/knip][4]
 - npm package: [knip][1]
 - [Contributing Guide][7]
+- Follow [@webpro.nl on Bluesky][3] for updates
 - [Sponsor Knip!][8]
 
 ## Contributors

package/dist/ConfigurationChief.d.ts

@@ -49,6 +49,7 @@ export declare class ConfigurationChief {
     getManifestForWorkspace(name: string): import("./types/package-json.js").PackageJson | undefined;
     private getDescendentWorkspaces;
     getIgnoredWorkspacesFor(name: string): string[];
+    createIgnoredWorkspaceMatcher(name: string, dir: string): (filePath: string) => boolean;
     getNegatedWorkspacePatterns(name: string): string[];
     private getConfigKeyForWorkspace;
     getWorkspaceConfig(workspaceName: string): {

package/dist/ConfigurationChief.js

@@ -270,6 +270,15 @@ export class ConfigurationChief {
             .filter(workspaceName => workspaceName !== name)
             .filter(workspaceName => name === ROOT_WORKSPACE_NAME || workspaceName.startsWith(name));
     }
+    createIgnoredWorkspaceMatcher(name, dir) {
+        const ignoredWorkspaces = this.getIgnoredWorkspacesFor(name);
+        if (ignoredWorkspaces.length === 0)
+            return () => false;
+        return (filePath) => {
+            const relativePath = filePath.startsWith(dir) ? filePath.slice(dir.length + 1) : filePath;
+            return picomatch.isMatch(relativePath, ignoredWorkspaces);
+        };
+    }
     getNegatedWorkspacePatterns(name) {
         const descendentWorkspaces = this.getDescendentWorkspaces(name);
         const matchName = new RegExp(`^${name}/`);

package/dist/IssueCollector.d.ts

@@ -1,6 +1,7 @@
 import type { IgnoreIssues } from './types/config.js';
 import type { ConfigurationHint, Issue, TagHint } from './types/issues.js';
 import type { MainOptions } from './util/create-options.js';
+export type CollectorIssues = ReturnType<IssueCollector['getIssues']>;
 export declare class IssueCollector {
     private cwd;
     private rules;

package/dist/ProjectPrincipal.js

@@ -54,7 +54,7 @@ export class ProjectPrincipal {
         this.syncCompilers = syncCompilers;
         this.asyncCompilers = asyncCompilers;
         this.cwd = options.cwd;
-        this.isWatch = options.isWatch;
+        this.isWatch = options.isWatch || options.isSession;
         this.cache = new CacheConsultant(pkgName || ANONYMOUS, options);
         this.toSourceFilePath = toSourceFilePath;
         this.backend = {
@@ -168,8 +168,7 @@ export class ProjectPrincipal {
         return _getImportsAndExports(sourceFile, resolve, typeChecker, options, ignoreExportsUsedInFile, skipExports);
     }
     invalidateFile(filePath) {
-        this.backend.fileManager.snapshotCache.delete(filePath);
-        this.backend.fileManager.sourceFileCache.delete(filePath);
+        this.backend.fileManager.invalidate(filePath);
     }
     findUnusedMembers(filePath, members) {
         if (!this.findReferences || !this.getImplementationAtPosition) {

package/dist/constants.d.ts

@@ -3,6 +3,7 @@ export declare const IMPORT_STAR = "*";
 export declare const ANONYMOUS = "__anonymous";
 export declare const KNIP_CONFIG_LOCATIONS: string[];
 export declare const DEFAULT_EXTENSIONS: string[];
+export declare const IS_DTS: RegExp;
 export declare const GLOBAL_IGNORE_PATTERNS: string[];
 export declare const PUBLIC_TAG = "@public";
 export declare const INTERNAL_TAG = "@internal";

package/dist/constants.js

@@ -12,6 +12,7 @@ export const KNIP_CONFIG_LOCATIONS = [
     'knip.config.js',
 ];
 export const DEFAULT_EXTENSIONS = ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx', '.mts', '.cts'];
+export const IS_DTS = /\.d\.(c|m)?ts$/;
 export const GLOBAL_IGNORE_PATTERNS = ['**/node_modules/**', '.yarn'];
 export const PUBLIC_TAG = '@public';
 export const INTERNAL_TAG = '@internal';

package/dist/graph/build.js

@@ -1,6 +1,7 @@
 import { _getInputsFromScripts } from '../binaries/index.js';
 import { getCompilerExtensions, getIncludedCompilers } from '../compilers/index.js';
-import { DEFAULT_EXTENSIONS, FOREIGN_FILE_EXTENSIONS } from '../constants.js';
+import { DEFAULT_EXTENSIONS, FOREIGN_FILE_EXTENSIONS, IS_DTS } from '../constants.js';
+import { partition } from '../util/array.js';
 import { debugLog, debugLogArray } from '../util/debug.js';
 import { getReferencedInputsHandler } from '../util/get-referenced-inputs.js';
 import { _glob, _syncGlob, negate, prependDirToPattern } from '../util/glob.js';
@@ -50,7 +51,8 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
         const extensionGlobStr = `.{${[...DEFAULT_EXTENSIONS, ...extensions].map(ext => ext.slice(1)).join(',')}}`;
         const config = chief.getConfigForWorkspace(name, extensions);
         const tsConfigFilePath = join(dir, options.tsConfigFile ?? 'tsconfig.json');
-        const { isFile, compilerOptions, definitionPaths } = await loadTSConfig(tsConfigFilePath);
+        const { isFile, compilerOptions, fileNames } = await loadTSConfig(tsConfigFilePath);
+        const [definitionPaths, tscSourcePaths] = partition(fileNames, filePath => IS_DTS.test(filePath));
         if (isFile)
             augmentWorkspace(workspace, dir, compilerOptions);
         const worker = new WorkspaceWorker({
@@ -204,7 +206,17 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                 principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
             }
         }
-        {
+        if (options.isUseTscFiles) {
+            const isIgnoredWorkspace = chief.createIgnoredWorkspaceMatcher(name, dir);
+            debugLogArray(name, 'Using tsconfig files as project files', tscSourcePaths);
+            for (const filePath of tscSourcePaths) {
+                if (!isGitIgnored(filePath) && !isIgnoredWorkspace(filePath)) {
+                    principal.addProgramPath(filePath);
+                    principal.addProjectPath(filePath);
+                }
+            }
+        }
+        else {
             const patterns = options.isProduction
                 ? worker.getProductionProjectFilePatterns(negatedEntryPatterns)
                 : worker.getProjectFilePatterns([
@@ -246,7 +258,7 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
         tags: options.tags,
     };
     const analyzeSourceFile = (filePath, principal) => {
-        if (!options.isWatch && analyzedFiles.has(filePath))
+        if (!options.isWatch && !options.isSession && analyzedFiles.has(filePath))
             return;
         analyzedFiles.add(filePath);
         const workspace = chief.findWorkspaceByFilePath(filePath);
@@ -355,13 +367,13 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
         for (const filePath of principal.entryPaths)
             entryPaths.add(filePath);
         principal.reconcileCache(graph);
-        if (options.isIsolateWorkspaces || (options.isSkipLibs && !options.isWatch)) {
+        if (options.isIsolateWorkspaces || (options.isSkipLibs && !options.isWatch && !options.isSession)) {
             factory.deletePrincipal(principal, options.cwd);
             principals[i] = undefined;
         }
         perfObserver.addMemoryMark(factory.getPrincipalCount());
     }
-    if (!options.isWatch && options.isSkipLibs && !options.isIsolateWorkspaces) {
+    if (!options.isWatch && !options.isSession && options.isSkipLibs && !options.isIsolateWorkspaces) {
         for (const principal of principals) {
             if (principal)
                 factory.deletePrincipal(principal, options.cwd);

package/dist/graph-explorer/cache.d.ts

@@ -0,0 +1,10 @@
+import type { ModuleGraph } from '../types/module-graph.js';
+import type { UsageResult } from './operations/get-usage.js';
+import type { DefinitionResult } from './operations/resolve-definition.js';
+export declare const invalidateCache: (graph: ModuleGraph) => void;
+export declare const getCachedDefinition: (graph: ModuleGraph, filePath: string, identifier: string) => DefinitionResult | null | undefined;
+export declare const setCachedDefinition: (graph: ModuleGraph, filePath: string, identifier: string, result: DefinitionResult | null) => void;
+export declare const getCachedUsage: (graph: ModuleGraph, filePath: string, identifier: string) => UsageResult | undefined;
+export declare const setCachedUsage: (graph: ModuleGraph, filePath: string, identifier: string, result: UsageResult) => void;
+export declare const getCachedExportedIdentifiers: (graph: ModuleGraph, filePath: string) => Map<string, boolean> | undefined;
+export declare const setCachedExportedIdentifiers: (graph: ModuleGraph, filePath: string, result: Map<string, boolean>) => void;

package/dist/graph-explorer/cache.js

@@ -0,0 +1,72 @@
+const caches = new WeakMap();
+const createEmptyCache = () => ({
+    definitions: new Map(),
+    usage: new Map(),
+    importLookup: new Map(),
+    exportedIdentifiers: new Map(),
+    generation: 0,
+});
+const getCache = (graph) => {
+    let cache = caches.get(graph);
+    if (!cache) {
+        cache = createEmptyCache();
+        caches.set(graph, cache);
+    }
+    return cache;
+};
+export const invalidateCache = (graph) => {
+    const cache = caches.get(graph);
+    if (cache) {
+        cache.definitions.clear();
+        cache.usage.clear();
+        cache.importLookup.clear();
+        cache.exportedIdentifiers.clear();
+        cache.generation++;
+    }
+};
+export const getCachedDefinition = (graph, filePath, identifier) => {
+    const cache = caches.get(graph);
+    if (!cache)
+        return undefined;
+    const fileCache = cache.definitions.get(filePath);
+    if (!fileCache)
+        return undefined;
+    return fileCache.has(identifier) ? fileCache.get(identifier) : undefined;
+};
+export const setCachedDefinition = (graph, filePath, identifier, result) => {
+    const cache = getCache(graph);
+    let fileCache = cache.definitions.get(filePath);
+    if (!fileCache) {
+        fileCache = new Map();
+        cache.definitions.set(filePath, fileCache);
+    }
+    fileCache.set(identifier, result);
+};
+export const getCachedUsage = (graph, filePath, identifier) => {
+    const cache = caches.get(graph);
+    if (!cache)
+        return undefined;
+    const fileCache = cache.usage.get(filePath);
+    if (!fileCache)
+        return undefined;
+    return fileCache.get(identifier);
+};
+export const setCachedUsage = (graph, filePath, identifier, result) => {
+    const cache = getCache(graph);
+    let fileCache = cache.usage.get(filePath);
+    if (!fileCache) {
+        fileCache = new Map();
+        cache.usage.set(filePath, fileCache);
+    }
+    fileCache.set(identifier, result);
+};
+export const getCachedExportedIdentifiers = (graph, filePath) => {
+    const cache = caches.get(graph);
+    if (!cache)
+        return undefined;
+    return cache.exportedIdentifiers.get(filePath);
+};
+export const setCachedExportedIdentifiers = (graph, filePath, result) => {
+    const cache = getCache(graph);
+    cache.exportedIdentifiers.set(filePath, result);
+};

package/dist/graph-explorer/constants.d.ts

@@ -1,2 +1,9 @@
 export declare const CONTINUE = "continue";
 export declare const STOP = "stop";
+export declare const RE_EXPORT_KIND: {
+    readonly ALIAS: "alias";
+    readonly NAMESPACE: "namespace";
+    readonly PASSTHROUGH: "passthrough";
+    readonly SELF: "self";
+    readonly STAR: "star";
+};

package/dist/graph-explorer/constants.js

@@ -1,2 +1,9 @@
 export const CONTINUE = 'continue';
 export const STOP = 'stop';
+export const RE_EXPORT_KIND = {
+    ALIAS: 'alias',
+    NAMESPACE: 'namespace',
+    PASSTHROUGH: 'passthrough',
+    SELF: 'self',
+    STAR: 'star',
+};

package/dist/graph-explorer/explorer.d.ts

@@ -8,4 +8,10 @@ export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<s
         filePath?: string;
         identifier?: string;
     }) => import("./operations/build-exports-tree.js").TreeNode[];
+    resolveDefinition: (filePath: string, identifier: string) => import("./operations/resolve-definition.js").DefinitionResult | null;
+    getUsage: (filePath: string, identifier: string) => import("./operations/get-usage.js").UsageResult;
+    findCycles: (filePath: string, maxDepth?: number) => import("../session/types.js").Cycle[];
+    getContention: (filePath: string) => Map<string, import("../session/types.js").ContentionDetails>;
+    invalidateCache: () => void;
 };
+export type GraphExplorer = ReturnType<typeof createGraphExplorer>;

package/dist/graph-explorer/explorer.js

@@ -1,10 +1,20 @@
+import { invalidateCache as invalidateCacheInternal } from './cache.js';
 import { buildExportsTree } from './operations/build-exports-tree.js';
+import { findCycles } from './operations/find-cycles.js';
+import { getContention } from './operations/get-contention.js';
+import { getUsage } from './operations/get-usage.js';
 import { hasStrictlyNsReferences } from './operations/has-strictly-ns-references.js';
 import { isReferenced } from './operations/is-referenced.js';
+import { resolveDefinition } from './operations/resolve-definition.js';
 export const createGraphExplorer = (graph, entryPaths) => {
     return {
         isReferenced: (filePath, identifier, options) => isReferenced(graph, entryPaths, filePath, identifier, options),
         hasStrictlyNsReferences: (filePath, identifier) => hasStrictlyNsReferences(graph, graph.get(filePath)?.imported, identifier),
         buildExportsTree: (options) => buildExportsTree(graph, entryPaths, options),
+        resolveDefinition: (filePath, identifier) => resolveDefinition(graph, filePath, identifier),
+        getUsage: (filePath, identifier) => getUsage(graph, entryPaths, filePath, identifier),
+        findCycles: (filePath, maxDepth) => findCycles(graph, filePath, maxDepth),
+        getContention: (filePath) => getContention(graph, filePath),
+        invalidateCache: () => invalidateCacheInternal(graph),
     };
 };

package/dist/graph-explorer/operations/find-cycles.d.ts

@@ -0,0 +1,3 @@
+import type { Cycle } from '../../session/types.js';
+import type { ModuleGraph } from '../../types/module-graph.js';
+export declare const findCycles: (graph: ModuleGraph, filePath: string, maxDepth?: number) => Cycle[];

package/dist/graph-explorer/operations/find-cycles.js

@@ -0,0 +1,38 @@
+export const findCycles = (graph, filePath, maxDepth = 16) => {
+    const cycles = [];
+    const visited = new Set();
+    const pathSet = new Set([filePath]);
+    const path = [filePath];
+    const visit = (currentPath) => {
+        if (path.length > maxDepth)
+            return;
+        const node = graph.get(currentPath);
+        if (!node?.imports?.internal)
+            return;
+        const nonTypeOnlyImports = new Set();
+        for (const _import of node.imports.imports) {
+            if (_import.filePath && !_import.isTypeOnly)
+                nonTypeOnlyImports.add(_import.filePath);
+        }
+        for (const [importedPath] of node.imports.internal) {
+            if (!nonTypeOnlyImports.has(importedPath))
+                continue;
+            if (importedPath === filePath) {
+                cycles.push([...path, importedPath]);
+                continue;
+            }
+            if (visited.has(importedPath))
+                continue;
+            if (!pathSet.has(importedPath)) {
+                path.push(importedPath);
+                pathSet.add(importedPath);
+                visit(importedPath);
+                pathSet.delete(importedPath);
+                path.pop();
+            }
+        }
+        visited.add(currentPath);
+    };
+    visit(filePath);
+    return cycles;
+};

package/dist/graph-explorer/operations/get-contention.d.ts

@@ -0,0 +1,3 @@
+import type { ContentionDetails } from '../../session/types.js';
+import type { ModuleGraph } from '../../types/module-graph.js';
+export declare const getContention: (graph: ModuleGraph, filePath: string) => Map<string, ContentionDetails>;

package/dist/graph-explorer/operations/get-contention.js

@@ -0,0 +1,142 @@
+import { IMPORT_STAR } from '../../constants.js';
+import { getExportedIdentifiers } from '../utils.js';
+import { forEachAliasReExport, forEachPassThroughReExport, getStarReExportSources } from '../visitors.js';
+export const getContention = (graph, filePath) => {
+    const node = graph.get(filePath);
+    if (!node)
+        return new Map();
+    const exportedIdentifiers = getExportedIdentifiers(graph, filePath);
+    const result = new Map();
+    for (const identifier of exportedIdentifiers.keys()) {
+        if (identifier === 'default')
+            continue;
+        const details = getContentionForIdentifier(graph, filePath, identifier);
+        if (details && (details.branching.length > 0 || details.conflict.length > 0)) {
+            result.set(identifier, details);
+        }
+    }
+    return result;
+};
+const getContentionForIdentifier = (graph, startFilePath, identifier) => {
+    const network = buildReExportNetwork(graph, startFilePath, identifier);
+    if (network.files.size <= 1)
+        return null;
+    const branchingFiles = [];
+    for (const file of network.files) {
+        const sourceCount = network.reExportsFrom.get(file)?.size ?? 0;
+        if (sourceCount > 1) {
+            branchingFiles.push(file);
+        }
+    }
+    const hasConflict = network.definitions.size > 1;
+    if (branchingFiles.length === 0 && !hasConflict)
+        return null;
+    return {
+        branching: branchingFiles.sort(),
+        conflict: hasConflict ? Array.from(network.definitions).sort() : [],
+    };
+};
+const buildReExportNetwork = (graph, startFilePath, identifier) => {
+    const network = {
+        files: new Set(),
+        definitions: new Set(),
+        reExportsFrom: new Map(),
+    };
+    const upVisited = new Set();
+    const downVisited = new Set();
+    walkUp(graph, network, startFilePath, identifier, upVisited);
+    walkDown(graph, network, startFilePath, identifier, downVisited);
+    for (const file of network.files) {
+        if (!upVisited.has(file)) {
+            walkUp(graph, network, file, identifier, upVisited);
+        }
+    }
+    for (const definitionFile of network.definitions) {
+        if (!downVisited.has(definitionFile))
+            walkDown(graph, network, definitionFile, identifier, downVisited);
+    }
+    return network;
+};
+const walkUp = (graph, network, filePath, identifier, visited) => {
+    if (visited.has(filePath))
+        return;
+    visited.add(filePath);
+    const node = graph.get(filePath);
+    if (!node)
+        return;
+    const exportedIds = getExportedIdentifiers(graph, filePath);
+    if (!exportedIds.has(identifier))
+        return;
+    network.files.add(filePath);
+    const exp = node.exports.get(identifier);
+    if (exp && !exp.isReExport) {
+        network.definitions.add(filePath);
+    }
+    for (const [sourcePath, importMaps] of node.imports.internal) {
+        forEachPassThroughReExport(importMaps, (id, _sources) => {
+            if (id !== identifier)
+                return;
+            addEdge(network, sourcePath, filePath);
+            walkUp(graph, network, sourcePath, identifier, visited);
+        });
+        forEachAliasReExport(importMaps, (sourceId, alias, _sources) => {
+            if (alias !== identifier)
+                return;
+            addEdge(network, sourcePath, filePath);
+            walkUp(graph, network, sourcePath, sourceId, visited);
+        });
+        const starSources = getStarReExportSources(importMaps);
+        if (starSources) {
+            const sourceExports = getExportedIdentifiers(graph, sourcePath);
+            if (sourceExports.has(identifier)) {
+                addEdge(network, sourcePath, filePath);
+                walkUp(graph, network, sourcePath, identifier, visited);
+            }
+        }
+    }
+};
+const walkDown = (graph, network, filePath, identifier, visited) => {
+    if (visited.has(filePath))
+        return;
+    visited.add(filePath);
+    const node = graph.get(filePath);
+    if (!node?.imported)
+        return;
+    const processConsumer = (consumerPath) => {
+        network.files.add(consumerPath);
+        addEdge(network, filePath, consumerPath);
+        const consumerExport = graph.get(consumerPath)?.exports.get(identifier);
+        if (consumerExport && !consumerExport.isReExport)
+            network.definitions.add(consumerPath);
+        walkDown(graph, network, consumerPath, identifier, visited);
+    };
+    const directConsumers = node.imported.reExported.get(identifier);
+    if (directConsumers) {
+        for (const consumerPath of directConsumers)
+            processConsumer(consumerPath);
+    }
+    for (const [sourceId, aliasMap] of node.imported.reExportedAs) {
+        if (sourceId === identifier) {
+            for (const [_alias, consumers] of aliasMap) {
+                for (const consumerPath of consumers)
+                    processConsumer(consumerPath);
+            }
+        }
+    }
+    const starConsumers = node.imported.reExported.get(IMPORT_STAR);
+    if (starConsumers) {
+        for (const consumerPath of starConsumers) {
+            const consumerExports = getExportedIdentifiers(graph, consumerPath);
+            if (consumerExports.has(identifier))
+                processConsumer(consumerPath);
+        }
+    }
+};
+const addEdge = (network, source, consumer) => {
+    let sources = network.reExportsFrom.get(consumer);
+    if (!sources) {
+        sources = new Set();
+        network.reExportsFrom.set(consumer, sources);
+    }
+    sources.add(source);
+};

package/dist/graph-explorer/operations/get-usage.d.ts

@@ -0,0 +1,13 @@
+import type { Identifier, ModuleGraph, Position } from '../../types/module-graph.js';
+import { type Via } from '../walk-down.js';
+export interface UsageLocation extends Position {
+    filePath: string;
+    identifier: string;
+    isEntry: boolean;
+    via: Via;
+}
+export interface UsageResult {
+    locations: UsageLocation[];
+    reExportingEntryFile: string | undefined;
+}
+export declare const getUsage: (graph: ModuleGraph, entryPaths: Set<string>, filePath: string, identifier: Identifier) => UsageResult;

package/dist/graph-explorer/operations/get-usage.js

@@ -0,0 +1,34 @@
+import { IMPORT_STAR } from '../../constants.js';
+import { getCachedUsage, setCachedUsage } from '../cache.js';
+import { CONTINUE } from '../constants.js';
+import { findImportRef } from '../utils.js';
+import { walkDown } from '../walk-down.js';
+export const getUsage = (graph, entryPaths, filePath, identifier) => {
+    const cached = getCachedUsage(graph, filePath, identifier);
+    if (cached)
+        return cached;
+    const locations = [];
+    let reExportingEntryFile;
+    if (entryPaths.has(filePath)) {
+        reExportingEntryFile = filePath;
+    }
+    walkDown(graph, filePath, identifier, (sourceFile, sourceId, importingFile, id, isEntry, via) => {
+        const lookupId = via === 'importNS' ? IMPORT_STAR : sourceId;
+        const importRef = findImportRef(graph, importingFile, sourceFile, lookupId);
+        locations.push({
+            filePath: importingFile,
+            identifier: id,
+            pos: importRef?.pos ?? 0,
+            line: importRef?.line ?? 0,
+            col: importRef?.col ?? 0,
+            isEntry,
+            via,
+        });
+        if (isEntry && !reExportingEntryFile)
+            reExportingEntryFile = importingFile;
+        return CONTINUE;
+    }, entryPaths);
+    const result = { locations, reExportingEntryFile };
+    setCachedUsage(graph, filePath, identifier, result);
+    return result;
+};

package/dist/graph-explorer/operations/resolve-definition.d.ts

@@ -0,0 +1,16 @@
+import type { ReExportKind } from '../../session/types.js';
+import type { Export, Identifier, ModuleGraph } from '../../types/module-graph.js';
+interface TraversalStep {
+    filePath: string;
+    identifier: string;
+    via: ReExportKind;
+}
+export interface DefinitionResult {
+    type: 'symbol' | 'namespace';
+    filePath: string;
+    identifier: string;
+    exportNode: Export | undefined;
+    chain: TraversalStep[];
+}
+export declare const resolveDefinition: (graph: ModuleGraph, filePath: string, identifier: Identifier) => DefinitionResult | null;
+export {};

package/dist/graph-explorer/operations/resolve-definition.js

@@ -0,0 +1,38 @@
+import { getCachedDefinition, setCachedDefinition } from '../cache.js';
+import { CONTINUE, STOP } from '../constants.js';
+import { walkUp } from '../walk-up.js';
+export const resolveDefinition = (graph, filePath, identifier) => {
+    const cached = getCachedDefinition(graph, filePath, identifier);
+    if (cached !== undefined)
+        return cached;
+    const chain = [];
+    let result = null;
+    walkUp(graph, filePath, identifier, (resolvedPath, resolvedId, via) => {
+        chain.push({ filePath: resolvedPath, identifier: resolvedId, via });
+        if (via === 'self') {
+            const node = graph.get(resolvedPath);
+            const exportNode = node?.exports.get(resolvedId);
+            result = {
+                type: 'symbol',
+                filePath: resolvedPath,
+                identifier: resolvedId,
+                exportNode,
+                chain,
+            };
+            return STOP;
+        }
+        if (via === 'namespace') {
+            result = {
+                type: 'namespace',
+                filePath: resolvedPath,
+                identifier: resolvedId,
+                exportNode: undefined,
+                chain,
+            };
+            return STOP;
+        }
+        return CONTINUE;
+    });
+    setCachedDefinition(graph, filePath, identifier, result);
+    return result;
+};

package/dist/graph-explorer/utils.d.ts

@@ -1,3 +1,5 @@
-import type { ImportMaps } from '../types/module-graph.js';
+import type { Import, ImportMaps, ModuleGraph } from '../types/module-graph.js';
+export declare const getExportedIdentifiers: (graph: ModuleGraph, filePath: string, visited?: Set<string>) => Map<string, boolean>;
 export declare const hasStrictlyEnumReferences: (importsForExport: ImportMaps | undefined, identifier: string) => boolean;
 export declare const getIssueType: (hasOnlyNsReference: boolean, isType: boolean) => "exports" | "nsExports" | "types" | "nsTypes";
+export declare const findImportRef: (graph: ModuleGraph, importingFile: string, importedFile: string, identifier: string) => Import | undefined;