knip 6.35.1 → 6.36.0

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

@@ -1,142 +1,285 @@
 import { IMPORT_STAR } from '../../constants.js';
-import { getExportedIdentifiers } from '../utils.js';
-import { forEachAliasReExport, forEachPassThroughReExport, getStarReExportSources } from '../visitors.js';
+import { compareStrings } from '../../util/string.js';
+import { createExportResolver } from './resolve-export-origins.js';
+const SEVERITY = { ambiguous: 3, shadowed: 2, converged: 1 };
 export const getContention = (graph, filePath) => {
+    const result = new Map();
     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 nodes = new Map([[filePath, node]]);
+    const getNode = (path) => {
+        if (nodes.has(path))
+            return nodes.get(path);
+        const found = graph.get(path);
+        nodes.set(path, found);
+        return found;
+    };
+    const positions = new Map();
+    const resolver = createExportResolver(graph);
+    const findOriginExport = (origin) => {
+        if (origin.identifier === IMPORT_STAR)
+            return;
+        const originNode = getNode(origin.filePath);
+        if (!originNode)
+            return;
+        const exact = originNode.exports.get(origin.identifier);
+        if (exact?.binding === origin.identifier)
+            return exact;
+        let nearest;
+        for (const _export of originNode.exports.values()) {
+            if (_export.binding !== origin.identifier)
+                continue;
+            if (!nearest || _export.pos < nearest.pos)
+                nearest = _export;
         }
-    }
-    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);
+        return nearest;
+    };
+    const locateOrigin = (origin) => {
+        const key = `${origin.filePath}:${origin.identifier}`;
+        const cached = positions.get(key);
+        if (cached)
+            return cached;
+        const _export = findOriginExport(origin);
+        const located = _export ? { ...origin, line: _export.line, col: _export.col } : { ...origin };
+        positions.set(key, located);
+        return located;
+    };
+    const materialize = (sitePath, identifier, entry, kind) => {
+        const isShadowed = kind === 'shadowed';
+        const origins = [];
+        for (const origin of (isShadowed && entry.shadowed ? entry.shadowed : entry.origins).values())
+            origins.push(locateOrigin(origin));
+        origins.sort((a, b) => compareStrings(a.filePath, b.filePath) || compareStrings(a.identifier, b.identifier));
+        const site = {
+            kind,
+            filePath: sitePath,
+            identifier,
+            origins,
+            sources: [...(isShadowed ? (entry.shadowedSources ?? []) : entry.sources.keys())],
+        };
+        const _export = getNode(sitePath)?.exports.get(identifier);
+        if (_export) {
+            site.line = _export.line;
+            site.col = _export.col;
         }
-    }
-    const hasConflict = network.definitions.size > 1;
-    if (branchingFiles.length === 0 && !hasConflict)
-        return null;
-    return {
-        branching: branchingFiles.sort(),
-        conflict: hasConflict ? Array.from(network.definitions).sort() : [],
+        if (isShadowed) {
+            const [winner] = entry.origins.values();
+            if (winner)
+                site.winner = locateOrigin(winner);
+        }
+        return site;
     };
-};
-const buildReExportNetwork = (graph, startFilePath, identifier) => {
-    const network = {
-        files: new Set(),
-        definitions: new Set(),
-        reExportsFrom: new Map(),
+    const compareSites = (describedIdentifier) => (a, b) => {
+        const isOwnA = a.filePath === filePath && a.identifier === describedIdentifier;
+        const isOwnB = b.filePath === filePath && b.identifier === describedIdentifier;
+        if (isOwnA !== isOwnB)
+            return isOwnA ? -1 : 1;
+        return (SEVERITY[b.kind] - SEVERITY[a.kind] ||
+            compareStrings(a.filePath, b.filePath) ||
+            compareStrings(a.identifier, b.identifier));
     };
-    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);
+    const sitesByFile = new Map();
+    const inspect = (sitePath, identifier) => {
+        let sites = sitesByFile.get(sitePath);
+        if (!sites)
+            sitesByFile.set(sitePath, (sites = new Map()));
+        if (identifier !== undefined && (sitePath === filePath || sites.has(identifier)))
+            return sites.get(identifier);
+        const info = resolver.getInfo(sitePath);
+        const table = identifier === undefined ? resolver.getTable(sitePath) : new Map();
+        if (identifier !== undefined) {
+            const entry = resolver.resolve(sitePath, identifier);
+            if (entry)
+                table.set(identifier, entry);
         }
-    }
-    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)
+        const entries = new Map();
+        const firstSources = new Map();
+        const addEntry = (name, resolution) => {
+            const entry = {
+                ...resolution,
+                sources: new Map(),
+                shadowed: undefined,
+                shadowedSources: undefined,
+            };
+            const first = firstSources.get(name);
+            if (first)
+                entry.sources.set(first.filePath, first);
+            entries.set(name, entry);
+            return entry;
+        };
+        for (const [name, entry] of table) {
+            if (entry.origins.size >= 2)
+                addEntry(name, entry);
+        }
+        const contribute = (name, source, origins, isStar) => {
+            const resolution = table.get(name);
+            if (!resolution || origins.size === 0)
                 return;
-            addEdge(network, sourcePath, filePath);
-            walkUp(graph, network, sourcePath, identifier, visited);
-        });
-        forEachAliasReExport(importMaps, (sourceId, alias, _sources) => {
-            if (alias !== identifier)
+            let entry = entries.get(name);
+            let contributes = false;
+            if (isStar && resolution.hasExplicitExport) {
+                for (const [key, origin] of origins) {
+                    if (resolution.origins.has(key))
+                        contributes = true;
+                    else {
+                        entry ??= addEntry(name, resolution);
+                        (entry.shadowed ??= new Map()).set(key, origin);
+                        (entry.shadowedSources ??= new Set()).add(source.filePath);
+                    }
+                }
+            }
+            else
+                contributes = true;
+            if (!contributes)
                 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 first = firstSources.get(name);
+            if (!entry && first && first.filePath !== source.filePath)
+                entry = addEntry(name, resolution);
+            if (entry)
+                entry.sources.set(source.filePath, source);
+            else
+                firstSources.set(name, source);
+        };
+        for (const [name, sources] of info.references) {
+            if (!table.has(name))
+                continue;
+            for (const source of sources) {
+                const entry = resolver.resolve(source.filePath, source.identifier);
+                if (entry)
+                    contribute(name, source, entry.origins, false);
             }
         }
-    }
-};
-const walkDown = (graph, network, filePath, identifier, visited) => {
-    if (visited.has(filePath))
-        return;
-    visited.add(filePath);
-    const node = graph.get(filePath);
-    if (!node?.importedBy)
-        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);
+        for (const [name, origins] of info.terminals) {
+            const entry = table.get(name);
+            if (!entry)
+                continue;
+            for (const origin of origins) {
+                if (origin.identifier === IMPORT_STAR && graph.has(origin.filePath))
+                    contribute(name, origin, entry.origins, false);
+            }
+        }
+        for (const sourcePath of info.stars) {
+            if (identifier === undefined) {
+                for (const [name, entry] of resolver.getTable(sourcePath)) {
+                    if (name !== 'default')
+                        contribute(name, { filePath: sourcePath, identifier: name }, entry.origins, true);
+                }
+            }
+            else if (identifier !== 'default') {
+                const entry = resolver.resolve(sourcePath, identifier);
+                if (entry)
+                    contribute(identifier, { filePath: sourcePath, identifier }, entry.origins, true);
+            }
+        }
+        for (const [name, entry] of entries) {
+            let kind;
+            if (entry.origins.size >= 2)
+                kind = 'ambiguous';
+            else if (entry.shadowed?.size)
+                kind = 'shadowed';
+            else if (entry.sources.size >= 2) {
+                const [origin] = entry.origins.values();
+                if (origin) {
+                    for (const [path, source] of entry.sources) {
+                        if (!resolver.reachesOrigin(source, origin, { filePath: sitePath, identifier: name }))
+                            entry.sources.delete(path);
+                    }
+                    if (entry.sources.size >= 2)
+                        kind = 'converged';
+                }
+            }
+            sites.set(name, kind ? materialize(sitePath, name, entry, kind) : undefined);
+        }
+        if (identifier !== undefined) {
+            if (!sites.has(identifier))
+                sites.set(identifier, undefined);
+            return sites.get(identifier);
+        }
     };
-    const directConsumers = node.importedBy.reExport.get(identifier);
-    if (directConsumers) {
-        for (const consumerPath of directConsumers)
-            processConsumer(consumerPath);
-    }
-    for (const [sourceId, aliasMap] of node.importedBy.reExportAs) {
-        if (sourceId === identifier) {
-            for (const [_alias, consumers] of aliasMap) {
+    inspect(filePath);
+    for (const [identifier, entry] of resolver.getTable(filePath)) {
+        if (identifier === 'default')
+            continue;
+        const sites = [];
+        const ownSite = inspect(filePath, identifier);
+        if (ownSite)
+            sites.push(ownSite);
+        else if (!node.importedBy?.reExport.size && !node.importedBy?.reExportAs.size)
+            continue;
+        const origins = entry.origins;
+        const visited = new Set([`${filePath}\0${identifier}`]);
+        const queue = [[filePath, identifier]];
+        const visitConsumer = (consumerPath, consumerId) => {
+            const key = `${consumerPath}\0${consumerId}`;
+            if (visited.has(key))
+                return;
+            visited.add(key);
+            const consumerEntry = resolver.resolve(consumerPath, consumerId);
+            if (!consumerEntry)
+                return;
+            const site = inspect(consumerPath, consumerId);
+            if (site)
+                sites.push(site);
+            if (site?.kind === 'ambiguous')
+                return;
+            for (const origin of consumerEntry.origins.keys()) {
+                if (origins.has(origin)) {
+                    queue.push([consumerPath, consumerId]);
+                    return;
+                }
+            }
+        };
+        for (let index = 0; index < queue.length; index++) {
+            const [currentPath, currentId] = queue[index];
+            const importedBy = getNode(currentPath)?.importedBy;
+            if (!importedBy)
+                continue;
+            const consumers = importedBy.reExport.get(currentId);
+            if (consumers)
                 for (const consumerPath of consumers)
-                    processConsumer(consumerPath);
+                    visitConsumer(consumerPath, currentId);
+            const aliases = importedBy.reExportAs.get(currentId);
+            if (aliases) {
+                for (const [alias, consumerPaths] of aliases) {
+                    for (const consumerPath of consumerPaths)
+                        visitConsumer(consumerPath, alias);
+                }
             }
+            const starConsumers = importedBy.reExport.get(IMPORT_STAR);
+            if (starConsumers)
+                for (const consumerPath of starConsumers)
+                    visitConsumer(consumerPath, currentId);
         }
-    }
-    const starConsumers = node.importedBy.reExport.get(IMPORT_STAR);
-    if (starConsumers) {
-        for (const consumerPath of starConsumers) {
-            const consumerExports = getExportedIdentifiers(graph, consumerPath);
-            if (consumerExports.has(identifier))
-                processConsumer(consumerPath);
+        if (sites.length === 0)
+            continue;
+        sites.sort(compareSites(identifier));
+        const branching = new Set();
+        const conflict = new Set();
+        for (const site of sites) {
+            if (site.kind === 'converged')
+                branching.add(site.filePath);
+            else {
+                let hasGraphOrigin = false;
+                for (const origin of site.origins) {
+                    if (!graph.has(origin.filePath))
+                        continue;
+                    conflict.add(origin.filePath);
+                    hasGraphOrigin = true;
+                }
+                if (site.winner && graph.has(site.winner.filePath)) {
+                    conflict.add(site.winner.filePath);
+                    hasGraphOrigin = true;
+                }
+                if (!hasGraphOrigin)
+                    conflict.add(site.filePath);
+            }
         }
+        result.set(identifier, {
+            branching: [...branching].sort(),
+            conflict: [...conflict].sort(),
+            sites,
+        });
     }
-};
-const addEdge = (network, source, consumer) => {
-    let sources = network.reExportsFrom.get(consumer);
-    if (!sources) {
-        sources = new Set();
-        network.reExportsFrom.set(consumer, sources);
-    }
-    sources.add(source);
+    return new Map([...result].sort(([a], [b]) => compareStrings(a, b)));
 };

package/dist/graph-explorer/operations/resolve-export-origins.d.ts

@@ -0,0 +1,32 @@
+import type { FileNode, ModuleGraph } from '../../types/module-graph.ts';
+export interface ExportOrigin {
+    filePath: string;
+    identifier: string;
+}
+export interface ExportOriginResolution {
+    origins: ExportOrigin[];
+    hasExplicitExport: boolean;
+}
+export interface ExportTableEntry {
+    origins: ReadonlyMap<string, ExportOrigin>;
+    hasExplicitExport: boolean;
+}
+export type ExportTable = Map<string, ExportTableEntry>;
+export interface ExportTableCache {
+    entries: ExportTable;
+    complete: boolean;
+}
+interface ExportInfo {
+    node: FileNode | undefined;
+    references: Map<string, ExportOrigin[]>;
+    terminals: Map<string, ExportOrigin[]>;
+    stars: string[];
+}
+export declare const createExportResolver: (graph: ModuleGraph) => {
+    getTable: (filePath: string) => ExportTable;
+    resolve: (filePath: string, identifier: string) => ExportTableEntry | undefined;
+    getInfo: (filePath: string) => ExportInfo;
+    reachesOrigin: (source: ExportOrigin, origin: ExportOrigin, site: ExportOrigin) => boolean;
+};
+export declare const resolveExportOrigins: (graph: ModuleGraph, filePath: string, identifier: string) => ExportOriginResolution;
+export {};