knip 5.70.2 → 5.71.0

package/dist/typescript/ast-helpers.js

@@ -203,6 +203,7 @@ export const isConsiderReferencedNS = (node) => ts.isPropertyAssignment(node.par
     ts.isSpreadAssignment(node.parent) ||
     ts.isArrayLiteralExpression(node.parent) ||
     ts.isExportAssignment(node.parent) ||
+    ts.isConditionalExpression(node.parent) ||
     (ts.isVariableDeclaration(node.parent) && node.parent.initializer === node) ||
     ts.isTypeQueryNode(node.parent.parent);
 export const isInOpaqueExpression = (node) => ts.isAwaitExpression(node.parent)
@@ -263,6 +264,18 @@ export const getImportMap = (sourceFile) => {
                     importMap.set(element.name.text, importPath);
             }
         }
+        if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (declaration.initializer &&
+                    isRequireCall(declaration.initializer) &&
+                    ts.isIdentifier(declaration.name) &&
+                    ts.isStringLiteral(declaration.initializer.arguments[0])) {
+                    const importName = declaration.name.text;
+                    const importPath = stripQuotes(declaration.initializer.arguments[0].text);
+                    importMap.set(importName, importPath);
+                }
+            }
+        }
     }
     return importMap;
 };
@@ -304,6 +317,32 @@ const isMatchAlias = (expression, identifier) => {
         expression = expression.expression;
     return expression && ts.isIdentifier(expression) && expression.escapedText === identifier;
 };
+export function getThenBindings(callExpression) {
+    if (!ts.isFunctionLike(callExpression.arguments[0]))
+        return;
+    const fn = callExpression.arguments[0];
+    const param = fn.parameters[0];
+    if (!param)
+        return;
+    if (ts.isIdentifier(param.name)) {
+        const paramName = param.name.escapedText;
+        const identifiers = [];
+        for (const node of findDescendants(fn.body, ts.isPropertyAccessExpression)) {
+            if (ts.isIdentifier(node.expression) && node.expression.escapedText === paramName) {
+                identifiers.push({ identifier: String(node.name.escapedText), pos: node.name.pos });
+            }
+        }
+        if (identifiers.length > 0)
+            return identifiers;
+    }
+    else if (ts.isObjectBindingPattern(param.name)) {
+        return param.name.elements.map(element => {
+            const identifier = (element.propertyName ?? element.name).getText();
+            const alias = element.propertyName ? element.name.getText() : undefined;
+            return { identifier, alias, pos: element.pos };
+        });
+    }
+}
 export const getAccessedIdentifiers = (identifier, scope) => {
     const identifiers = [];
     function visit(node) {
@@ -328,6 +367,15 @@ export const getAccessedIdentifiers = (identifier, scope) => {
                 }
             }
         }
+        else if (ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            isMatchAlias(node.expression.expression, identifier) &&
+            node.expression.name.escapedText === 'then') {
+            const accessed = getThenBindings(node);
+            if (accessed)
+                for (const acc of accessed)
+                    identifiers.push(acc);
+        }
         ts.forEachChild(node, visit);
     }
     visit(scope);

package/dist/typescript/get-imports-and-exports.js

@@ -190,9 +190,11 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
     const addExport = ({ node, symbol, identifier, type, pos, members = [], fix }) => {
         if (skipExports)
             return;
+        let isReExport = Boolean(node.parent?.parent && ts.isExportDeclaration(node.parent.parent) && node.parent.parent.moduleSpecifier);
         if (symbol) {
             const importedSymbolFilePath = importedInternalSymbols.get(symbol);
             if (importedSymbolFilePath) {
+                isReExport = true;
                 const importId = String(symbol.escapedName);
                 const internalImport = internal.get(importedSymbolFilePath);
                 if (internalImport) {
@@ -215,7 +217,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
             const members = [...(item.members ?? []), ...exportMembers];
             const tags = new Set([...(item.jsDocTags ?? []), ...jsDocTags]);
             const fixes = fix ? [...(item.fixes ?? []), fix] : item.fixes;
-            exports.set(identifier, { ...item, members, jsDocTags: tags, fixes });
+            exports.set(identifier, { ...item, members, jsDocTags: tags, fixes, isReExport });
         }
         else {
             const { line, character } = node.getSourceFile().getLineAndCharacterOfPosition(pos);
@@ -230,6 +232,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                 col: character + 1,
                 fixes: fix ? [fix] : [],
                 refs: [0, false],
+                isReExport,
             });
         }
         if (!jsDocTags.has(ALIAS_TAG)) {

package/dist/typescript/visitors/dynamic-imports/importCall.js

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 import { IMPORT_MODIFIERS } from '../../../constants.js';
-import { findAncestor, findDescendants, getAccessedIdentifiers, isAccessExpression, isImportCall, isInOpaqueExpression, isTopLevel, stripQuotes, } from '../../ast-helpers.js';
+import { findAncestor, findDescendants, getAccessedIdentifiers, getThenBindings, isAccessExpression, isImportCall, isInOpaqueExpression, isTopLevel, stripQuotes, } from '../../ast-helpers.js';
 import { importVisitor as visit } from '../index.js';
 const getSymbol = (node, isTopLevel) => (isTopLevel ? node.symbol : undefined);
 export default visit(() => true, node => {
@@ -20,24 +20,10 @@ export default visit(() => true, node => {
                         const pos = accessExpression.name.pos;
                         if (identifier === 'then') {
                             const callExpression = node.parent.parent;
-                            if (ts.isCallExpression(callExpression) && ts.isFunctionLike(callExpression.arguments[0])) {
-                                const arg = callExpression.arguments[0].parameters[0];
-                                if (arg && ts.isIdentifier(arg.name)) {
-                                    const argName = arg.name.escapedText;
-                                    const accessExpressions = findDescendants(callExpression.arguments[0].body, ts.isPropertyAccessExpression).filter(binding => binding.expression.getText() === argName);
-                                    if (accessExpressions.length > 0) {
-                                        return accessExpressions.map(binding => {
-                                            const identifier = String(binding.name.escapedText);
-                                            return { identifier, specifier, pos, modifiers };
-                                        });
-                                    }
-                                }
-                                else if (arg && ts.isObjectBindingPattern(arg.name)) {
-                                    return arg.name.elements.map(element => {
-                                        const identifier = (element.propertyName ?? element.name).getText();
-                                        const alias = element.propertyName ? element.name.getText() : undefined;
-                                        return { identifier, alias, specifier, pos: element.pos, modifiers };
-                                    });
+                            if (ts.isCallExpression(callExpression)) {
+                                const accessed = getThenBindings(callExpression);
+                                if (accessed && accessed.length > 0) {
+                                    return accessed.map(acc => ({ ...acc, specifier, modifiers }));
                                 }
                             }
                             return { identifier: 'default', specifier, pos, modifiers };

package/dist/util/create-options.js

@@ -115,7 +115,7 @@ export const createOptions = async (options) => {
         rules,
         tags,
         traceExport: parsedCLIArgs['trace-export'],
-        traceFile: parsedCLIArgs['trace-file'],
+        traceFile: parsedCLIArgs['trace-file'] ? toAbsolute(parsedCLIArgs['trace-file'], cwd) : undefined,
         tsConfigFile: parsedCLIArgs.tsConfig,
         workspace: options.workspace ?? parsedCLIArgs.workspace,
         workspaces,

package/dist/util/file-entry-cache.js

@@ -86,7 +86,7 @@ export class FileEntryCache {
     }
     reconcile() {
         this.removeNotFoundFiles();
-        for (const [entryName, cacheEntry] of this.normalizedEntries.entries()) {
+        for (const [entryName, cacheEntry] of this.normalizedEntries) {
             try {
                 const meta = this._getMetaForFileUsingMtimeAndSize(cacheEntry);
                 this.cache.set(entryName, meta);

package/dist/util/graph-sequencer.js

@@ -6,7 +6,7 @@ export function graphSequencer(graph, includedNodes = [...graph.keys()]) {
     const nodes = new Set(includedNodes);
     const visited = new Set();
     const outDegree = new Map();
-    for (const [from, edges] of graph.entries()) {
+    for (const [from, edges] of graph) {
         outDegree.set(from, 0);
         for (const to of edges) {
             if (nodes.has(from) && nodes.has(to)) {

package/dist/util/module-graph.js

@@ -2,21 +2,21 @@ export const getOrCreateFileNode = (graph, filePath) => graph.get(filePath) ?? c
 const updateImportMaps = (fromImportMaps, toImportMaps) => {
     for (const id of fromImportMaps.refs)
         toImportMaps.refs.add(id);
-    for (const [id, v] of fromImportMaps.imported.entries())
+    for (const [id, v] of fromImportMaps.imported)
         addValues(toImportMaps.imported, id, v);
-    for (const [id, v] of fromImportMaps.importedAs.entries())
+    for (const [id, v] of fromImportMaps.importedAs)
         addNsValues(toImportMaps.importedAs, id, v);
-    for (const [id, v] of fromImportMaps.importedNs.entries())
+    for (const [id, v] of fromImportMaps.importedNs)
         addValues(toImportMaps.importedNs, id, v);
-    for (const [id, v] of fromImportMaps.reExported.entries())
+    for (const [id, v] of fromImportMaps.reExported)
         addValues(toImportMaps.reExported, id, v);
-    for (const [id, v] of fromImportMaps.reExportedAs.entries())
+    for (const [id, v] of fromImportMaps.reExportedAs)
         addNsValues(toImportMaps.reExportedAs, id, v);
-    for (const [id, v] of fromImportMaps.reExportedNs.entries())
+    for (const [id, v] of fromImportMaps.reExportedNs)
         addValues(toImportMaps.reExportedNs, id, v);
 };
 export const updateImportMap = (file, importMap, graph) => {
-    for (const [importedFilePath, fileImportMaps] of importMap.entries()) {
+    for (const [importedFilePath, fileImportMaps] of importMap) {
         const importMaps = file.imports.internal.get(importedFilePath);
         if (!importMaps)
             file.imports.internal.set(importedFilePath, fileImportMaps);

package/dist/util/trace.d.ts

@@ -1,20 +1,10 @@
-import type { ModuleGraph } from '../types/module-graph.js';
 import type { MainOptions } from './create-options.js';
-type CreateNodeOpts = {
-    identifier?: string;
-    hasRef?: boolean;
-    isEntry?: boolean;
-};
-type Create = (filePath: string, options?: CreateNodeOpts) => TraceNode;
-export type TraceNode = {
+type ExplorerTraceNode = {
     filePath: string;
     identifier?: string;
     hasRef: boolean;
     isEntry: boolean;
-    children: Set<TraceNode>;
+    children: ExplorerTraceNode[];
 };
-export declare const printTrace: (node: TraceNode, filePath: string, options: MainOptions, identifier?: string) => void;
-export declare const createNode: Create;
-export declare const addNodes: (node: TraceNode, id: string, importedSymbols: ModuleGraph, filePaths?: Set<string>) => void;
-export declare const createAndPrintTrace: (filePath: string, options: MainOptions, opts?: CreateNodeOpts) => void;
+export declare const printTraceNode: (node: ExplorerTraceNode, options: MainOptions) => void;
 export {};

package/dist/util/trace.js

@@ -1,5 +1,5 @@
 import picocolors from 'picocolors';
-import { toAbsolute, toRelative } from './path.js';
+import { toRelative } from './path.js';
 const IS_ENTRY = ' ◯';
 const HAS_REF = ' ✓';
 const HAS_NO_REF = ' x';
@@ -9,62 +9,31 @@ const getPadding = (level, levels) => {
         padding += levels.has(i) ? `${picocolors.dim('│')}  ` : '   ';
     return padding;
 };
-const renderTrace = (node, options, level = 0, levels = new Set()) => {
+const renderExplorerTrace = (node, options, level = 0, levels = new Set()) => {
     let index = 0;
-    const size = node.children.size;
+    const size = node.children.length;
     const padding = getPadding(level, levels);
     for (const child of node.children) {
         const isLast = ++index === size;
         const hasRef = child.hasRef === true;
         const rel = toRelative(child.filePath, options.cwd);
         const file = hasRef ? rel : picocolors.dim(rel);
-        const suffix = (hasRef ? HAS_REF : '') + (child.isEntry ? IS_ENTRY : '');
+        const suffix = hasRef ? HAS_REF : '';
         const text = `${padding}${picocolors.dim(isLast ? '└─' : '├─')} ${file}${suffix}`;
         console.log(text);
-        if (child.children.size > 0) {
+        if (child.children.length > 0) {
             if (!isLast)
                 levels.add(level);
             if (isLast)
                 levels.delete(level);
-            renderTrace(child, options, level + 1, levels);
+            renderExplorerTrace(child, options, level + 1, levels);
         }
     }
 };
-export const printTrace = (node, filePath, options, identifier) => {
-    if (!options.isTrace)
-        return;
-    if (options.traceExport && identifier !== options.traceExport)
-        return;
-    if (options.traceFile && filePath !== toAbsolute(options.traceFile, options.cwd))
-        return;
-    const suffix = (node.isEntry ? IS_ENTRY : '') + (node.children.size === 0 ? HAS_NO_REF : '');
-    const header = `${toRelative(filePath, options.cwd)}${identifier ? `:${identifier}` : ''}${suffix}`;
+export const printTraceNode = (node, options) => {
+    const suffix = (node.isEntry ? IS_ENTRY : '') + (node.children.length === 0 ? HAS_NO_REF : '');
+    const header = `${toRelative(node.filePath, options.cwd)}${node.identifier ? `:${node.identifier}` : ''}${suffix}`;
     console.log(header);
-    renderTrace(node, options);
+    renderExplorerTrace(node, options);
     console.log();
 };
-export const createNode = (filePath, { hasRef = false, isEntry = false, identifier } = {}) => ({
-    filePath,
-    identifier,
-    hasRef,
-    isEntry,
-    children: new Set(),
-});
-const addNode = (parent, filePath, { hasRef = false, isEntry = false }) => {
-    const node = createNode(filePath, { hasRef, isEntry });
-    parent.children.add(node);
-    return node;
-};
-export const addNodes = (node, id, importedSymbols, filePaths) => {
-    if (!filePaths)
-        return;
-    for (const filePath of filePaths) {
-        addNode(node, filePath, { hasRef: Boolean(importedSymbols.get(filePath)?.traceRefs?.has(id)) });
-    }
-};
-export const createAndPrintTrace = (filePath, options, opts = {}) => {
-    if (!options.isTrace)
-        return;
-    const traceNode = createNode(filePath, opts);
-    printTrace(traceNode, filePath, options, opts.identifier);
-};

package/dist/util/watch.d.ts

@@ -6,10 +6,16 @@ import type { ProjectPrincipal } from '../ProjectPrincipal.js';
 import type { Issues } from '../types/issues.js';
 import type { ModuleGraph } from '../types/module-graph.js';
 import type { MainOptions } from './create-options.js';
-export type OnUpdate = (options: {
+export type OnFileChange = (options: {
     issues: Issues;
     duration?: number;
+    mem?: number;
 }) => void;
+type WatchChange = {
+    type: 'added' | 'deleted' | 'modified';
+    filePath: string;
+};
+export type WatchHandler = Awaited<ReturnType<typeof getWatchHandler>>;
 type Watch = {
     analyzedFiles: Set<string>;
     analyzeSourceFile: (filePath: string, principal: ProjectPrincipal) => void;
@@ -19,8 +25,18 @@ type Watch = {
     factory: PrincipalFactory;
     graph: ModuleGraph;
     isIgnored: (path: string) => boolean;
-    onUpdate: OnUpdate;
+    onFileChange?: OnFileChange;
     unreferencedFiles: Set<string>;
+    entryPaths: Set<string>;
 };
-export declare const getWatchHandler: (options: MainOptions, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, factory, graph, isIgnored, onUpdate, unreferencedFiles, }: Watch) => Promise<WatchListener<string | Buffer<ArrayBufferLike>>>;
+export declare const getWatchHandler: (options: MainOptions, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, factory, graph, isIgnored, onFileChange, unreferencedFiles, entryPaths, }: Watch) => Promise<{
+    listener: WatchListener<string | Buffer<ArrayBufferLike>>;
+    handleFileChanges: (changes: WatchChange[]) => Promise<{
+        duration: number;
+        mem: number;
+    }>;
+    getEntryPaths: () => Set<string>;
+    getGraph: () => ModuleGraph;
+    getIssues: () => Issues;
+}>;
 export {};

package/dist/util/watch.js

@@ -2,18 +2,23 @@ import { debugLog } from './debug.js';
 import { isFile } from './fs.js';
 import { updateImportMap } from './module-graph.js';
 import { join, toAbsolute, toRelative } from './path.js';
-export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, factory, graph, isIgnored, onUpdate, unreferencedFiles, }) => {
+const createUpdate = (options) => {
+    const duration = performance.now() - options.startTime;
+    const mem = process.memoryUsage().heapUsed;
+    return { duration, mem };
+};
+export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, factory, graph, isIgnored, onFileChange, unreferencedFiles, entryPaths, }) => {
     const getIssues = () => collector.getIssues().issues;
-    const processBatch = async (changes) => {
+    const handleFileChanges = async (changes) => {
         const startTime = performance.now();
         const added = new Set();
         const deleted = new Set();
         const modified = new Set();
-        for (const [type, _path] of changes) {
-            const filePath = toAbsolute(_path, options.cwd);
-            const relativePath = toRelative(_path, options.cwd);
+        for (const change of changes) {
+            const filePath = toAbsolute(change.filePath, options.cwd);
+            const relativePath = toRelative(change.filePath, options.cwd);
             if (isIgnored(filePath)) {
-                debugLog('*', `ignoring ${type} ${relativePath}`);
+                debugLog('*', `ignoring ${change.type} ${relativePath}`);
                 continue;
             }
             const workspace = chief.findWorkspaceByFilePath(filePath);
@@ -22,7 +27,7 @@ export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFil
             const principal = factory.getPrincipalByPackageName(workspace.pkgName);
             if (!principal)
                 continue;
-            switch (type) {
+            switch (change.type) {
                 case 'added':
                     added.add(filePath);
                     principal.addProjectPath(filePath);
@@ -35,7 +40,7 @@ export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFil
                     principal.removeProjectPath(filePath);
                     debugLog(workspace.name, `Watcher: - ${relativePath}`);
                     break;
-                case 'modified':
+                default:
                     modified.add(filePath);
                     debugLog(workspace.name, `Watcher: ± ${relativePath}`);
                     break;
@@ -43,7 +48,7 @@ export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFil
             principal.invalidateFile(filePath);
         }
         if (added.size === 0 && deleted.size === 0 && modified.size === 0)
-            return;
+            return createUpdate({ startTime });
         unreferencedFiles.clear();
         const cachedUnusedFiles = collector.purge();
         for (const filePath of added)
@@ -110,15 +115,21 @@ export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFil
         collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
         for (const issue of collector.getRetainedIssues())
             collector.addIssue(issue);
-        onUpdate({ issues: getIssues(), duration: performance.now() - startTime });
+        const update = createUpdate({ startTime });
+        if (onFileChange)
+            onFileChange(Object.assign({ issues: getIssues() }, update));
+        return update;
     };
-    const listener = (eventType, filename) => {
-        debugLog('*', `(raw) ${eventType} ${filename}`);
-        if (typeof filename === 'string') {
-            const event = eventType === 'rename' ? (isFile(join(options.cwd, filename)) ? 'added' : 'deleted') : 'modified';
-            processBatch([[event, filename]]);
+    const listener = (eventType, filePath) => {
+        debugLog('*', `(raw) ${eventType} ${filePath}`);
+        if (typeof filePath === 'string') {
+            const type = eventType === 'rename' ? (isFile(join(options.cwd, filePath)) ? 'added' : 'deleted') : 'modified';
+            handleFileChanges([{ type, filePath }]);
         }
     };
-    onUpdate({ issues: getIssues() });
-    return listener;
+    if (onFileChange)
+        onFileChange({ issues: getIssues() });
+    const getEntryPaths = () => entryPaths;
+    const getGraph = () => graph;
+    return { listener, handleFileChanges, getEntryPaths, getGraph, getIssues };
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.70.2";
+export declare const version = "5.71.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.70.2';
+export const version = '5.71.0';

package/package.json

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

package/vendor/bash-parser/index.d.ts

@@ -43,6 +43,11 @@ type Function_ = {
   body: CompoundList;
 };
 
+type Subshell = {
+  type: 'Subshell';
+  list: CompoundList;
+};
+
 export type ExpansionNode = {
   expansion: Expansion[];
 };
@@ -62,7 +67,7 @@ export type Assignment = {
   text: string;
 };
 
-export type Node = CompoundList | Command | LogicalExpression | If | For | Function_ | Pipeline;
+export type Node = CompoundList | Command | LogicalExpression | If | For | Function_ | Pipeline | Subshell;
 
 export type AST = {
   type: 'Script';

package/dist/util/has-strictly-ns-references.d.ts

@@ -1,4 +0,0 @@
-import type { ImportMaps, ModuleGraph } from '../types/module-graph.js';
-export declare const hasStrictlyEnumReferences: (importsForExport: ImportMaps | undefined, id: string) => boolean;
-export declare const hasStrictlyNsReferences: (graph: ModuleGraph, importsForExport: ImportMaps | undefined, id: string) => [boolean, string?];
-export declare const getType: (hasOnlyNsReference: boolean, isType: boolean) => "exports" | "nsExports" | "types" | "nsTypes";

package/dist/util/has-strictly-ns-references.js

@@ -1,103 +0,0 @@
-import { IMPORT_STAR } from '../constants.js';
-export const hasStrictlyEnumReferences = (importsForExport, id) => {
-    if (!importsForExport || !importsForExport.refs.has(id))
-        return false;
-    for (const ref of importsForExport.refs)
-        if (ref.startsWith(`${id}.`))
-            return false;
-    return true;
-};
-export const hasStrictlyNsReferences = (graph, importsForExport, id) => {
-    if (!importsForExport)
-        return [false];
-    let namespace;
-    for (const ns of importsForExport.importedNs.keys()) {
-        const hasNs = importsForExport.refs.has(ns);
-        if (!hasNs)
-            return [false, ns];
-        for (const id of importsForExport.refs)
-            if (id.startsWith(`${ns}.`))
-                return [false, ns];
-        const byFilePaths = importsForExport.reExportedNs.get(ns);
-        if (byFilePaths) {
-            for (const filePath of byFilePaths) {
-                const file = graph.get(filePath);
-                if (file?.imported) {
-                    const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, id);
-                    if (hasStrictlyNsRefs[0] === false)
-                        return hasStrictlyNsRefs;
-                }
-            }
-        }
-        const reExportedAs = importsForExport.reExportedAs.get(ns);
-        if (reExportedAs) {
-            for (const byFilePaths of reExportedAs.values()) {
-                for (const filePath of byFilePaths) {
-                    const file = graph.get(filePath);
-                    if (file?.imported) {
-                        const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, id);
-                        if (hasStrictlyNsRefs[0] === false)
-                            return hasStrictlyNsRefs;
-                    }
-                }
-            }
-        }
-        namespace = ns;
-    }
-    const byFilePaths = importsForExport.reExported.get(id);
-    if (byFilePaths) {
-        for (const filePath of byFilePaths) {
-            const file = graph.get(filePath);
-            if (file?.imported) {
-                const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, id);
-                if (hasStrictlyNsRefs[0] === false)
-                    return hasStrictlyNsRefs;
-                namespace = hasStrictlyNsRefs[1];
-            }
-        }
-    }
-    {
-        const byFilePaths = importsForExport.reExported.get(IMPORT_STAR);
-        if (byFilePaths) {
-            for (const filePath of byFilePaths) {
-                const file = graph.get(filePath);
-                if (file?.imported) {
-                    const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, id);
-                    if (hasStrictlyNsRefs[0] === false)
-                        return hasStrictlyNsRefs;
-                    namespace = hasStrictlyNsRefs[1];
-                }
-            }
-        }
-    }
-    const [identifier, ...rest] = id.split('.');
-    const reExportedAs = importsForExport.reExportedAs.get(identifier);
-    if (reExportedAs) {
-        for (const [alias, filePaths] of reExportedAs.entries()) {
-            for (const filePath of filePaths) {
-                const file = graph.get(filePath);
-                if (file?.imported) {
-                    const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, [alias, ...rest].join('.'));
-                    if (hasStrictlyNsRefs[0] === false)
-                        return hasStrictlyNsRefs;
-                    namespace = hasStrictlyNsRefs[1];
-                }
-            }
-        }
-    }
-    for (const [ns, filePaths] of importsForExport.reExportedNs.entries()) {
-        for (const filePath of filePaths) {
-            const file = graph.get(filePath);
-            if (file?.imported) {
-                const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, `${ns}.${id}`);
-                if (hasStrictlyNsRefs[0] === false)
-                    return hasStrictlyNsRefs;
-                namespace = hasStrictlyNsRefs[1];
-            }
-        }
-    }
-    if (namespace)
-        return [true, namespace];
-    return [false];
-};
-export const getType = (hasOnlyNsReference, isType) => hasOnlyNsReference ? (isType ? 'nsTypes' : 'nsExports') : isType ? 'types' : 'exports';

package/dist/util/is-identifier-referenced.d.ts

@@ -1,9 +0,0 @@
-import type { ModuleGraph } from '../types/module-graph.js';
-import { type TraceNode } from './trace.js';
-type Result = {
-    isReferenced: boolean;
-    reExportingEntryFile: undefined | string;
-    traceNode: TraceNode;
-};
-export declare const getIsIdentifierReferencedHandler: (graph: ModuleGraph, entryPaths: Set<string>, isTrace: boolean) => (filePath: string, id: string, isIncludeEntryExports?: boolean, traceNode?: TraceNode, seen?: Set<string>) => Result;
-export {};