knip 5.70.2 → 5.71.0

package/dist/DependencyDeputy.js

@@ -174,7 +174,7 @@ export class DependencyDeputy {
         const dependencyIssues = [];
         const devDependencyIssues = [];
         const optionalPeerDependencyIssues = [];
-        for (const [workspace, { manifestPath: filePath, manifestStr }] of this._manifests.entries()) {
+        for (const [workspace, { manifestPath: filePath, manifestStr }] of this._manifests) {
             const referencedDependencies = this.referencedDependencies.get(workspace);
             const hasTypesIncluded = this.getHasTypesIncluded(workspace);
             const peeker = new PackagePeeker(manifestStr);
@@ -342,7 +342,7 @@ export class DependencyDeputy {
     }
     getConfigurationHints() {
         const configurationHints = new Set();
-        for (const [workspaceName, manifest] of this._manifests.entries()) {
+        for (const [workspaceName, manifest] of this._manifests) {
             for (const identifier of manifest.unusedIgnoreDependencies) {
                 configurationHints.add({ workspaceName, identifier, type: 'ignoreDependencies' });
             }

package/dist/ProjectPrincipal.js

@@ -217,7 +217,7 @@ export class ProjectPrincipal {
         return externalRefs.length > 0;
     }
     reconcileCache(graph) {
-        for (const [filePath, file] of graph.entries()) {
+        for (const [filePath, file] of graph) {
             const fd = this.cache.getFileDescriptor(filePath);
             if (!fd?.meta)
                 continue;

package/dist/WorkspaceWorker.js

@@ -319,7 +319,7 @@ export class WorkspaceWorker {
             const configFiles = this.configFilesMap.get(wsName);
             if (configFiles) {
                 do {
-                    for (const [pluginName, dependencies] of configFiles.entries()) {
+                    for (const [pluginName, dependencies] of configFiles) {
                         configFiles.delete(pluginName);
                         if (this.enabledPlugins.includes(pluginName)) {
                             for (const input of await runPlugin(pluginName, Array.from(dependencies)))

package/dist/binaries/bash-parser.js

@@ -25,6 +25,12 @@ export const getDependenciesFromScript = (script, options) => {
             knownBinsOnly: false,
         });
     };
+    const definedFunctions = new Set();
+    const collectFunctionNames = (nodes) => {
+        for (const node of nodes)
+            if (node.type === 'Function')
+                definedFunctions.add(node.name.text);
+    };
     const getDependenciesFromNodes = (nodes) => nodes.flatMap(node => {
         switch (node.type) {
             case 'Command': {
@@ -41,6 +47,8 @@ export const getDependenciesFromScript = (script, options) => {
                     return [];
                 if (binary.startsWith('-') || binary.startsWith('"') || binary.startsWith('..'))
                     return [];
+                if (definedFunctions.has(binary))
+                    return [];
                 const args = node.suffix?.map(arg => arg.text) ?? [];
                 if (['!', 'test'].includes(binary))
                     return fromArgs(args);
@@ -82,13 +90,18 @@ export const getDependenciesFromScript = (script, options) => {
                 return getDependenciesFromNodes(node.commands);
             case 'Function':
                 return getDependenciesFromNodes(node.body.commands);
+            case 'Subshell':
+                return getDependenciesFromNodes(node.list.commands);
             default:
                 return [];
         }
     });
     try {
         const parsed = parse(script);
-        return parsed?.commands ? getDependenciesFromNodes(parsed.commands) : [];
+        if (!parsed?.commands)
+            return [];
+        collectFunctionNames(parsed.commands);
+        return getDependenciesFromNodes(parsed.commands);
     }
     catch (error) {
         const msg = `Warning: failed to parse and ignoring script in ${relative(options.cwd, options.containingFilePath)} (${truncate(script, 30)})`;

package/dist/compilers/index.js

@@ -38,7 +38,7 @@ const compilers = new Map([
 ]);
 export const getIncludedCompilers = (syncCompilers, asyncCompilers, dependencies) => {
     const hasDependency = (packageName) => dependencies.has(packageName);
-    for (const [extension, { condition, compiler }] of compilers.entries()) {
+    for (const [extension, { condition, compiler }] of compilers) {
         if (extension === '.mdx' && AstroMDX.condition(hasDependency)) {
             syncCompilers.set(extension, AstroMDX.compiler);
         }

package/dist/constants.js

@@ -89,6 +89,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'rmdir',
     'rsync',
     'scp',
+    'sed',
     'seq',
     'set',
     'sh',

package/dist/graph/analyze.js

@@ -1,13 +1,13 @@
-import { getType, hasStrictlyEnumReferences, hasStrictlyNsReferences } from '../util/has-strictly-ns-references.js';
-import { getIsIdentifierReferencedHandler } from '../util/is-identifier-referenced.js';
+import { createGraphExplorer } from '../graph-explorer/explorer.js';
+import { getIssueType, hasStrictlyEnumReferences } from '../graph-explorer/utils.js';
 import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
 import { findMatch } from '../util/regex.js';
 import { getShouldIgnoreHandler, getShouldIgnoreTagHandler } from '../util/tag.js';
-import { createAndPrintTrace, printTrace } from '../util/trace.js';
+import { printTraceNode } from '../util/trace.js';
 export const analyze = async ({ analyzedFiles, counselor, chief, collector, deputy, entryPaths, factory, graph, streamer, unreferencedFiles, options, }) => {
     const shouldIgnore = getShouldIgnoreHandler(options.isProduction);
     const shouldIgnoreTags = getShouldIgnoreTagHandler(options.tags);
-    const isIdentifierReferenced = getIsIdentifierReferencedHandler(graph, entryPaths, options.isTrace);
+    const explorer = createGraphExplorer(graph, entryPaths);
     const ignoreExportsUsedInFile = chief.config.ignoreExportsUsedInFile;
     const isExportedItemReferenced = (exportedItem) => exportedItem.refs[1] ||
         (exportedItem.refs[0] > 0 &&
@@ -17,7 +17,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
     const analyzeGraph = async () => {
         if (options.isReportValues || options.isReportTypes) {
             streamer.cast('Connecting the dots');
-            for (const [filePath, file] of graph.entries()) {
+            for (const [filePath, file] of graph) {
                 const exportItems = file.exports;
                 if (!exportItems || exportItems.size === 0)
                     continue;
@@ -27,16 +27,17 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                     const principal = factory.getPrincipalByPackageName(workspace.pkgName);
                     const isEntry = entryPaths.has(filePath);
                     if (!isIncludeEntryExports && isEntry) {
-                        createAndPrintTrace(filePath, options, { isEntry });
                         continue;
                     }
                     const importsForExport = file.imported;
-                    for (const [identifier, exportedItem] of exportItems.entries()) {
+                    for (const [identifier, exportedItem] of exportItems) {
                         if (shouldIgnore(exportedItem.jsDocTags))
                             continue;
                         const isIgnored = shouldIgnoreTags(exportedItem.jsDocTags);
                         if (importsForExport) {
-                            const { isReferenced, reExportingEntryFile, traceNode } = isIdentifierReferenced(filePath, identifier, isIncludeEntryExports);
+                            const [isReferenced, reExportingEntryFile] = explorer.isReferenced(filePath, identifier, {
+                                includeEntryExports: isIncludeEntryExports,
+                            });
                             if ((isReferenced || exportedItem.refs[1]) && isIgnored) {
                                 for (const tagName of exportedItem.jsDocTags) {
                                     if (options.tags[1].includes(tagName.replace(/^@/, ''))) {
@@ -48,15 +49,12 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                 continue;
                             if (reExportingEntryFile) {
                                 if (!isIncludeEntryExports) {
-                                    createAndPrintTrace(filePath, options, { identifier, isEntry, hasRef: isReferenced });
                                     continue;
                                 }
                                 const reExportedItem = graph.get(reExportingEntryFile)?.exports.get(identifier);
                                 if (reExportedItem && shouldIgnore(reExportedItem.jsDocTags))
                                     continue;
                             }
-                            if (traceNode)
-                                printTrace(traceNode, filePath, options, identifier);
                             if (isReferenced) {
                                 if (options.includedIssueTypes.enumMembers && exportedItem.type === 'enum') {
                                     if (!options.includedIssueTypes.nsTypes && importsForExport.refs.has(identifier))
@@ -70,9 +68,11 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                             continue;
                                         if (member.refs[0] === 0) {
                                             const id = `${identifier}.${member.identifier}`;
-                                            const { isReferenced } = isIdentifierReferenced(filePath, id, true);
+                                            const [isMemberReferenced] = explorer.isReferenced(filePath, id, {
+                                                includeEntryExports: true,
+                                            });
                                             const isIgnored = shouldIgnoreTags(member.jsDocTags);
-                                            if (!isReferenced) {
+                                            if (!isMemberReferenced) {
                                                 if (isIgnored)
                                                     continue;
                                                 collector.addIssue({
@@ -125,7 +125,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                 continue;
                             }
                         }
-                        const [hasStrictlyNsRefs, namespace] = hasStrictlyNsReferences(graph, importsForExport, identifier);
+                        const [hasStrictlyNsRefs, namespace] = explorer.hasStrictlyNsReferences(filePath, identifier);
                         const isType = ['enum', 'type', 'interface'].includes(exportedItem.type);
                         if (hasStrictlyNsRefs &&
                             ((!options.includedIssueTypes.nsTypes && isType) || !(options.includedIssueTypes.nsExports || isType)))
@@ -135,7 +135,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                 continue;
                             if (!options.isSkipLibs && principal?.hasExternalReferences(filePath, exportedItem))
                                 continue;
-                            const type = getType(hasStrictlyNsRefs, isType);
+                            const type = getIssueType(hasStrictlyNsRefs, isType);
                             collector.addIssue({
                                 type,
                                 filePath,
@@ -153,7 +153,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                 }
             }
         }
-        for (const [filePath, file] of graph.entries()) {
+        for (const [filePath, file] of graph) {
             const ws = chief.findWorkspaceByFilePath(filePath);
             if (ws) {
                 if (file.duplicates && options.includedIssueTypes.duplicates) {
@@ -227,5 +227,10 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
             collector.addConfigurationHint(hint);
     };
     await analyzeGraph();
+    if (options.isTrace) {
+        const nodes = explorer.buildExportsTree({ filePath: options.traceFile, identifier: options.traceExport });
+        for (const node of nodes)
+            printTraceNode(node, options);
+    }
     return analyzeGraph;
 };

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

@@ -0,0 +1,2 @@
+export declare const CONTINUE = "continue";
+export declare const STOP = "stop";

package/dist/graph-explorer/constants.js

@@ -0,0 +1,2 @@
+export const CONTINUE = 'continue';
+export const STOP = 'stop';

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

@@ -0,0 +1,11 @@
+import type { ModuleGraph } from '../types/module-graph.js';
+export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<string>) => {
+    isReferenced: (filePath: string, identifier: string, options: {
+        includeEntryExports: boolean;
+    }) => [boolean, string | undefined];
+    hasStrictlyNsReferences: (filePath: string, identifier: string) => [boolean, (string | undefined)?];
+    buildExportsTree: (options: {
+        filePath?: string;
+        identifier?: string;
+    }) => import("./operations/build-trace-tree.js").TreeNode[];
+};

package/dist/graph-explorer/explorer.js

@@ -0,0 +1,10 @@
+import { buildExportsTree } from './operations/build-trace-tree.js';
+import { hasStrictlyNsReferences } from './operations/has-strictly-ns-references.js';
+import { isReferenced } from './operations/is-referenced.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),
+    };
+};

package/dist/graph-explorer/operations/build-trace-tree.d.ts

@@ -0,0 +1,12 @@
+import type { Identifier, ModuleGraph } from '../../types/module-graph.js';
+export interface TreeNode {
+    filePath: string;
+    identifier: string;
+    hasRef: boolean;
+    isEntry: boolean;
+    children: TreeNode[];
+}
+export declare const buildExportsTree: (graph: ModuleGraph, entryPaths: Set<string>, options: {
+    filePath?: string;
+    identifier?: Identifier;
+}) => TreeNode[];

package/dist/graph-explorer/operations/build-trace-tree.js

@@ -0,0 +1,51 @@
+import { CONTINUE } from '../constants.js';
+import { walkDown } from '../walk-down.js';
+export const buildExportsTree = (graph, entryPaths, options) => {
+    const traces = [];
+    const processFile = (filePath, file) => {
+        for (const exportId of options.identifier ? [options.identifier] : file.exports.keys()) {
+            if (!options.identifier || file.exports.has(exportId)) {
+                const trace = buildExportTree(graph, entryPaths, filePath, exportId);
+                if (trace)
+                    traces.push(trace);
+            }
+        }
+    };
+    if (options.filePath) {
+        const file = graph.get(options.filePath);
+        if (file)
+            processFile(options.filePath, file);
+    }
+    else {
+        for (const [filePath, file] of graph)
+            processFile(filePath, file);
+    }
+    return traces;
+};
+const buildExportTree = (graph, entryPaths, filePath, identifier) => {
+    const rootNode = {
+        filePath,
+        identifier,
+        hasRef: false,
+        isEntry: entryPaths.has(filePath),
+        children: [],
+    };
+    const nodeMap = new Map();
+    nodeMap.set(`${filePath}:${identifier}`, rootNode);
+    walkDown(graph, filePath, identifier, (sourceFile, sourceId, importingFile, id, isEntry, isReExport) => {
+        const key = `${importingFile}:${id}`;
+        const childNode = nodeMap.get(key) ?? {
+            filePath: importingFile,
+            identifier: id,
+            hasRef: !isReExport && Boolean(graph.get(importingFile)?.traceRefs?.has(id)),
+            isEntry,
+            children: [],
+        };
+        nodeMap.set(key, childNode);
+        const parentKey = `${sourceFile}:${sourceId}`;
+        const parentNode = nodeMap.get(parentKey) ?? rootNode;
+        parentNode.children.push(childNode);
+        return CONTINUE;
+    }, entryPaths);
+    return rootNode;
+};

package/dist/graph-explorer/operations/has-strictly-ns-references.d.ts

@@ -0,0 +1,2 @@
+import type { ImportMaps, ModuleGraph } from '../../types/module-graph.js';
+export declare const hasStrictlyNsReferences: (graph: ModuleGraph, importsForExport: ImportMaps | undefined, identifier: string) => [boolean, string?];

package/dist/graph-explorer/operations/has-strictly-ns-references.js

@@ -0,0 +1,98 @@
+import { forEachAliasReExport, forEachNamespaceReExport, forEachPassThroughReExport, getStarReExportSources, } from '../visitors.js';
+export const hasStrictlyNsReferences = (graph, importsForExport, identifier) => {
+    if (!importsForExport)
+        return [false];
+    let foundNamespace;
+    const aliasByIdentifier = new Map();
+    const namespaceReExports = new Map();
+    const namespaceEdges = [];
+    const directById = new Map();
+    forEachPassThroughReExport(importsForExport, (id, sources) => {
+        directById.set(id, sources);
+    });
+    forEachAliasReExport(importsForExport, (id, alias, sources) => {
+        let arr = aliasByIdentifier.get(id);
+        if (!arr) {
+            arr = [];
+            aliasByIdentifier.set(id, arr);
+        }
+        arr.push({ alias, sources });
+    });
+    forEachNamespaceReExport(importsForExport, (namespace, sources) => {
+        namespaceEdges.push({ namespace, sources });
+        let arr = namespaceReExports.get(namespace);
+        if (!arr) {
+            arr = [];
+            namespaceReExports.set(namespace, arr);
+        }
+        arr.push(sources);
+    });
+    const starSources = getStarReExportSources(importsForExport);
+    const followReExports = (sources, nextId, propagateNamespace = true) => {
+        for (const filePath of sources) {
+            const file = graph.get(filePath);
+            if (!file?.imported)
+                continue;
+            const result = hasStrictlyNsReferences(graph, file.imported, nextId);
+            if (result[0] === false)
+                return result;
+            if (propagateNamespace && result[1])
+                foundNamespace = result[1];
+        }
+        return undefined;
+    };
+    for (const ns of importsForExport.importedNs.keys()) {
+        const hasNsRef = importsForExport.refs.has(ns);
+        if (!hasNsRef)
+            return [false, ns];
+        for (const ref of importsForExport.refs) {
+            if (ref.startsWith(`${ns}.`))
+                return [false, ns];
+        }
+        const nsReExports = namespaceReExports.get(ns);
+        if (nsReExports) {
+            for (const sources of nsReExports) {
+                const result = followReExports(sources, identifier, false);
+                if (result)
+                    return result;
+            }
+        }
+        const nsAliases = aliasByIdentifier.get(ns);
+        if (nsAliases) {
+            for (const { sources } of nsAliases) {
+                const result = followReExports(sources, identifier, false);
+                if (result)
+                    return result;
+            }
+        }
+        foundNamespace = ns;
+    }
+    const directSources = directById.get(identifier);
+    if (directSources) {
+        const result = followReExports(directSources, identifier, true);
+        if (result)
+            return result;
+    }
+    if (starSources) {
+        const result = followReExports(starSources, identifier, true);
+        if (result)
+            return result;
+    }
+    const [id, ...rest] = identifier.split('.');
+    const aliasEntries = aliasByIdentifier.get(id);
+    if (aliasEntries) {
+        for (const { alias, sources } of aliasEntries) {
+            const result = followReExports(sources, [alias, ...rest].join('.'), true);
+            if (result)
+                return result;
+        }
+    }
+    for (const { namespace: ns, sources } of namespaceEdges) {
+        const result = followReExports(sources, `${ns}.${identifier}`, true);
+        if (result)
+            return result;
+    }
+    if (foundNamespace)
+        return [true, foundNamespace];
+    return [false];
+};

package/dist/graph-explorer/operations/is-referenced.d.ts

@@ -0,0 +1,4 @@
+import type { Identifier, ModuleGraph } from '../../types/module-graph.js';
+export declare const isReferenced: (graph: ModuleGraph, entryPaths: Set<string>, filePath: string, id: Identifier, options: {
+    includeEntryExports: boolean;
+}) => [boolean, string | undefined];

package/dist/graph-explorer/operations/is-referenced.js

@@ -0,0 +1,89 @@
+import { OPAQUE } from '../../constants.js';
+import { getAliasReExportMap, getNamespaceReExportSources, getPassThroughReExportSources, getStarReExportSources, } from '../visitors.js';
+export const isReferenced = (graph, entryPaths, filePath, id, options) => {
+    const seen = new Set();
+    const check = (currentPath, currentId) => {
+        const isEntryFile = entryPaths.has(currentPath);
+        let reExportingEntryFile = isEntryFile ? currentPath : undefined;
+        if (isEntryFile && !options.includeEntryExports)
+            return [false, reExportingEntryFile];
+        if (seen.has(currentPath))
+            return [false, reExportingEntryFile];
+        seen.add(currentPath);
+        const restIds = currentId.split('.');
+        const identifier = restIds.shift();
+        const file = graph.get(currentPath)?.imported;
+        if (!identifier || !file) {
+            return [false, reExportingEntryFile];
+        }
+        const directSources = getPassThroughReExportSources(file, identifier);
+        const starSources = getStarReExportSources(file);
+        const followSources = (sources, nextId) => {
+            for (const byFilePath of sources) {
+                if (seen.has(byFilePath))
+                    continue;
+                const result = check(byFilePath, nextId);
+                if (result[1])
+                    reExportingEntryFile = result[1];
+                if (result[0])
+                    return true;
+            }
+            return false;
+        };
+        if (file.imported.get(OPAQUE) ||
+            ((identifier === currentId || (identifier !== currentId && file.refs.has(currentId))) &&
+                (file.imported.has(identifier) || file.importedAs.has(identifier)))) {
+            return [true, reExportingEntryFile];
+        }
+        for (const [exportId, aliases] of file.importedAs) {
+            if (identifier === exportId) {
+                for (const alias of aliases.keys()) {
+                    const aliasedRef = [alias, ...restIds].join('.');
+                    if (file.refs.has(aliasedRef)) {
+                        return [true, reExportingEntryFile];
+                    }
+                }
+            }
+        }
+        for (const namespace of file.importedNs.keys()) {
+            if (file.refs.has(`${namespace}.${currentId}`)) {
+                return [true, reExportingEntryFile];
+            }
+            const nsAliasMap = getAliasReExportMap(file, namespace);
+            if (nsAliasMap) {
+                for (const [alias, sources] of nsAliasMap) {
+                    if (followSources(sources, `${alias}.${currentId}`))
+                        return [true, reExportingEntryFile];
+                }
+            }
+            const nsReExportSources = getNamespaceReExportSources(file, namespace);
+            if (nsReExportSources) {
+                if (followSources(nsReExportSources, `${namespace}.${currentId}`))
+                    return [true, reExportingEntryFile];
+            }
+        }
+        const aliasMap = getAliasReExportMap(file, identifier);
+        if (aliasMap) {
+            for (const [alias, sources] of aliasMap) {
+                const ref = [alias, ...restIds].join('.');
+                if (followSources(sources, ref))
+                    return [true, reExportingEntryFile];
+            }
+        }
+        if (directSources) {
+            if (followSources(directSources, currentId))
+                return [true, reExportingEntryFile];
+        }
+        else if (starSources) {
+            if (followSources(starSources, currentId))
+                return [true, reExportingEntryFile];
+        }
+        for (const [namespace, sources] of file.reExportedNs) {
+            if (followSources(sources, `${namespace}.${currentId}`)) {
+                return [true, reExportingEntryFile];
+            }
+        }
+        return [false, reExportingEntryFile];
+    };
+    return check(filePath, id);
+};

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

@@ -0,0 +1,4 @@
+import type { ImportMaps, ModuleGraph } from '../types/module-graph.js';
+export declare const hasNamespaceMemberReference: (graph: ModuleGraph, importingFile: string, importedFile: string, namespace: string, member: string) => boolean | null;
+export declare const hasStrictlyEnumReferences: (importsForExport: ImportMaps | undefined, identifier: string) => boolean;
+export declare const getIssueType: (hasOnlyNsReference: boolean, isType: boolean) => "exports" | "nsExports" | "types" | "nsTypes";

package/dist/graph-explorer/utils.js

@@ -0,0 +1,28 @@
+import { OPAQUE } from '../constants.js';
+export const hasNamespaceMemberReference = (graph, importingFile, importedFile, namespace, member) => {
+    const importerNode = graph.get(importingFile);
+    if (!importerNode)
+        return null;
+    const importMap = importerNode.imports.internal.get(importedFile);
+    if (!importMap)
+        return null;
+    if (importMap.imported.get(OPAQUE))
+        return true;
+    if (importMap.refs.size === 0)
+        return false;
+    const refKey = member ? `${namespace}.${member}` : namespace;
+    return refKey ? importMap.refs.has(refKey) : null;
+};
+export const hasStrictlyEnumReferences = (importsForExport, identifier) => {
+    if (!importsForExport || !importsForExport.refs.has(identifier))
+        return false;
+    for (const ref of importsForExport.refs)
+        if (ref.startsWith(`${identifier}.`))
+            return false;
+    return true;
+};
+export const getIssueType = (hasOnlyNsReference, isType) => {
+    if (hasOnlyNsReference)
+        return isType ? 'nsTypes' : 'nsExports';
+    return isType ? 'types' : 'exports';
+};

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

@@ -0,0 +1,12 @@
+import type { ImportMaps } from '../types/module-graph.js';
+type PassThroughReExportCallback = (identifier: string, sources: Set<string>) => boolean | void;
+type AliasReExportCallback = (identifier: string, alias: string, sources: Set<string>) => boolean | void;
+type NamespaceReExportCallback = (namespace: string, sources: Set<string>) => boolean | void;
+export declare const forEachPassThroughReExport: (importMaps: ImportMaps, callback: PassThroughReExportCallback) => boolean;
+export declare const forEachAliasReExport: (importMaps: ImportMaps, callback: AliasReExportCallback) => boolean;
+export declare const forEachNamespaceReExport: (importMaps: ImportMaps, callback: NamespaceReExportCallback) => boolean;
+export declare const getStarReExportSources: (importMaps: ImportMaps) => Set<string> | undefined;
+export declare const getPassThroughReExportSources: (importMaps: ImportMaps, identifier: string) => Set<string> | undefined;
+export declare const getAliasReExportMap: (importMaps: ImportMaps, identifier: string) => Map<string, Set<string>> | undefined;
+export declare const getNamespaceReExportSources: (importMaps: ImportMaps, namespace: string) => Set<string> | undefined;
+export {};

package/dist/graph-explorer/visitors.js

@@ -0,0 +1,30 @@
+import { IMPORT_STAR } from '../constants.js';
+export const forEachPassThroughReExport = (importMaps, callback) => {
+    for (const [identifier, sources] of importMaps.reExported) {
+        if (identifier === IMPORT_STAR)
+            continue;
+        if (callback(identifier, sources ?? new Set()) === false)
+            return false;
+    }
+    return true;
+};
+export const forEachAliasReExport = (importMaps, callback) => {
+    for (const [identifier, aliasMap] of importMaps.reExportedAs) {
+        for (const [alias, sources] of aliasMap) {
+            if (callback(identifier, alias, sources ?? new Set()) === false)
+                return false;
+        }
+    }
+    return true;
+};
+export const forEachNamespaceReExport = (importMaps, callback) => {
+    for (const [namespace, sources] of importMaps.reExportedNs) {
+        if (callback(namespace, sources ?? new Set()) === false)
+            return false;
+    }
+    return true;
+};
+export const getStarReExportSources = (importMaps) => importMaps.reExported.get(IMPORT_STAR);
+export const getPassThroughReExportSources = (importMaps, identifier) => importMaps.reExported.get(identifier);
+export const getAliasReExportMap = (importMaps, identifier) => importMaps.reExportedAs.get(identifier);
+export const getNamespaceReExportSources = (importMaps, namespace) => importMaps.reExportedNs.get(namespace);

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

@@ -0,0 +1,4 @@
+import type { ModuleGraph } from '../types/module-graph.js';
+type Visitor = (sourceFile: string, identifier: string, importingFile: string, identifierPath: string, isEntry: boolean, isReExport: boolean) => 'continue' | 'stop' | undefined;
+export declare const walkDown: (graph: ModuleGraph, filePath: string, identifier: string, visitor: Visitor, entryPaths: Set<string>, visited?: Set<string>) => boolean;
+export {};