knip 5.70.2 → 5.72.0

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

@@ -29,7 +29,7 @@ const createMember = (node, member, pos) => {
         line: line + 1,
         col: character + 1,
         fix: member.fix,
-        refs: [0, false],
+        self: [0, false],
         jsDocTags: getJSDocTags(member.node),
     };
 };
@@ -42,19 +42,24 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
     const exports = new Map();
     const aliasedExports = new Map();
     const scripts = new Set();
-    const traceRefs = new Set();
     const importedInternalSymbols = new Map();
+    const importAliases = new Map();
+    const addImportAlias = (aliasName, id, filePath) => {
+        const aliases = importAliases.get(aliasName);
+        if (aliases)
+            aliases.add({ id, filePath });
+        else
+            importAliases.set(aliasName, new Set([{ id, filePath }]));
+    };
     const referencedSymbolsInExport = new Set();
     const visitors = getVisitors(sourceFile);
     const addNsMemberRefs = (internalImport, namespace, member) => {
         if (typeof member === 'string') {
             internalImport.refs.add(`${namespace}.${member}`);
-            traceRefs.add(`${namespace}.${member}`);
         }
         else {
             for (const m of member) {
                 internalImport.refs.add(`${namespace}.${m}`);
-                traceRefs.add(`${namespace}.${m}`);
             }
         }
     };
@@ -190,9 +195,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 +222,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);
@@ -229,7 +236,8 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                 line: line + 1,
                 col: character + 1,
                 fixes: fix ? [fix] : [],
-                refs: [0, false],
+                self: [0, false],
+                isReExport,
             });
         }
         if (!jsDocTags.has(ALIAS_TAG)) {
@@ -282,13 +290,25 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         if (ts.isIdentifier(node)) {
             const id = String(node.escapedText);
             const { symbol, filePath } = getImport(id, node);
+            if (importAliases.has(id) && isAccessExpression(node.parent)) {
+                const members = getAccessMembers(typeChecker, node);
+                for (const { id: aliasedId, filePath: aliasFilePath } of importAliases.get(id)) {
+                    const aliasImports = internal.get(aliasFilePath);
+                    if (aliasImports)
+                        addNsMemberRefs(aliasImports, aliasedId, members);
+                }
+            }
             if (symbol) {
                 if (filePath) {
                     if (!isImportSpecifier(node)) {
                         const imports = internal.get(filePath);
                         if (imports) {
-                            traceRefs.add(id);
-                            if (isAccessExpression(node.parent)) {
+                            const isPropName = ts.isPropertyAccessExpression(node.parent) && node.parent.name === node;
+                            if (isPropName && isAccessExpression(node.parent.parent)) {
+                                const members = getAccessMembers(typeChecker, node.parent);
+                                addNsMemberRefs(imports, id, members);
+                            }
+                            else if (isAccessExpression(node.parent) && !isPropName) {
                                 if (isDestructuring(node.parent)) {
                                     if (ts.isPropertyAccessExpression(node.parent)) {
                                         const ns = String(symbol.escapedName);
@@ -315,6 +335,25 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                                 else
                                     addNsMemberRefs(imports, id, members);
                             }
+                            else if (ts.isSpreadAssignment(node.parent)) {
+                                const path = [];
+                                let _node = node.parent;
+                                while (_node && !ts.isVariableDeclaration(_node)) {
+                                    if (ts.isPropertyAssignment(_node) && ts.isIdentifier(_node.name))
+                                        path.unshift(_node.name.text);
+                                    _node = _node.parent;
+                                }
+                                if (_node && ts.isIdentifier(_node.name)) {
+                                    const varName = _node.name.text;
+                                    if (exports.has(varName)) {
+                                        addNsValue(imports.reExportedAs, id, [varName, ...path].join('.'), sourceFile.fileName);
+                                    }
+                                    else if (path.length === 0) {
+                                        addImportAlias(varName, id, filePath);
+                                    }
+                                }
+                                imports.refs.add(id);
+                            }
                             else {
                                 const typeRef = getTypeRef(node);
                                 if (typeRef) {
@@ -328,6 +367,34 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                                         imports.refs.add(id);
                                     }
                                 }
+                                else if (ts.isVariableDeclaration(node.parent) &&
+                                    node.parent.initializer === node &&
+                                    ts.isIdentifier(node.parent.name)) {
+                                    const aliasName = node.parent.name.text;
+                                    if (exports.has(aliasName)) {
+                                        addNsValue(imports.reExportedAs, id, aliasName, sourceFile.fileName);
+                                    }
+                                    else {
+                                        addImportAlias(aliasName, id, filePath);
+                                        imports.refs.add(id);
+                                    }
+                                }
+                                else if (ts.isConditionalExpression(node.parent) || ts.isBinaryExpression(node.parent)) {
+                                    let _node = node.parent;
+                                    while (_node && !ts.isVariableDeclaration(_node))
+                                        _node = _node.parent;
+                                    if (_node && ts.isIdentifier(_node.name))
+                                        addImportAlias(_node.name.text, id, filePath);
+                                    imports.refs.add(id);
+                                }
+                                else if (ts.isShorthandPropertyAssignment(node.parent)) {
+                                    let _node = node.parent;
+                                    while (_node && !ts.isVariableDeclaration(_node))
+                                        _node = _node.parent;
+                                    if (_node && ts.isIdentifier(_node.name))
+                                        addImportAlias(`${_node.name.text}.${id}`, id, filePath);
+                                    imports.refs.add(id);
+                                }
                                 else if (imports.importedNs.has(id) && isConsiderReferencedNS(node)) {
                                     imports.refs.add(id);
                                 }
@@ -355,7 +422,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
             addImport(node, sourceFile);
     for (const item of exports.values()) {
         if (!isType(item) && item.symbol && referencedSymbolsInExport.has(item.symbol)) {
-            item.refs = [1, true];
+            item.self = [1, true];
         }
         else {
             const isBindingElement = item.symbol?.valueDeclaration && ts.isBindingElement(item.symbol.valueDeclaration);
@@ -364,11 +431,11 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                     item.type !== 'unknown' &&
                     ignoreExportsUsedInFile[item.type]) ||
                 isBindingElement) {
-                item.refs = findInternalReferences(item, sourceFile, typeChecker, referencedSymbolsInExport, isBindingElement);
+                item.self = findInternalReferences(item, sourceFile, typeChecker, referencedSymbolsInExport, isBindingElement);
             }
         }
         for (const member of item.members) {
-            member.refs = findInternalReferences(member, sourceFile, typeChecker, referencedSymbolsInExport);
+            member.self = findInternalReferences(member, sourceFile, typeChecker, referencedSymbolsInExport);
             member.symbol = undefined;
         }
         item.symbol = undefined;
@@ -378,7 +445,6 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         exports,
         duplicates: [...aliasedExports.values()],
         scripts,
-        traceRefs,
     };
 };
 export const _getImportsAndExports = timerify(getImportsAndExports);

package/dist/typescript/resolve-module-names.js

@@ -5,7 +5,7 @@ import { DEFAULT_EXTENSIONS } from '../constants.js';
 import { sanitizeSpecifier } from '../util/modules.js';
 import { timerify } from '../util/Performance.js';
 import { dirname, extname, isAbsolute, isInNodeModules, join } from '../util/path.js';
-import { _createSyncResolver, _resolveSync } from '../util/resolve.js';
+import { _createSyncModuleResolver, _resolveModuleSync } from '../util/resolve.js';
 import { isDeclarationFileExtension } from './ast-helpers.js';
 const resolutionCache = new Map();
 const fileExists = (name, containingFile) => {
@@ -19,10 +19,11 @@ const fileExists = (name, containingFile) => {
         };
     }
 };
+const tsResolveModuleName = timerify(ts.resolveModuleName);
 export function createCustomModuleResolver(compilerOptions, customCompilerExtensions, toSourceFilePath, useCache = true, isSkipLibs = true) {
     const customCompilerExtensionsSet = new Set(customCompilerExtensions);
     const extensions = [...DEFAULT_EXTENSIONS, ...customCompilerExtensions];
-    const resolveSync = customCompilerExtensionsSet.size === 0 ? _resolveSync : _createSyncResolver(extensions);
+    const resolveSync = customCompilerExtensionsSet.size === 0 ? _resolveModuleSync : _createSyncModuleResolver(extensions);
     const virtualDeclarationFiles = new Map();
     const tsSys = {
         ...ts.sys,
@@ -57,7 +58,7 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
         const sanitizedSpecifier = sanitizeSpecifier(name);
         if (isBuiltin(sanitizedSpecifier))
             return undefined;
-        const resolvedFileName = isSkipLibs && resolveSync(sanitizedSpecifier, dirname(containingFile));
+        const resolvedFileName = isSkipLibs && resolveSync(sanitizedSpecifier, containingFile);
         if (resolvedFileName) {
             const ext = extname(resolvedFileName);
             if (!customCompilerExtensionsSet.has(ext)) {
@@ -78,7 +79,7 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
                 resolvedUsingTsExtension: false,
             };
         }
-        const tsResolvedModule = ts.resolveModuleName(sanitizedSpecifier, containingFile, compilerOptions, tsSys).resolvedModule;
+        const tsResolvedModule = tsResolveModuleName(sanitizedSpecifier, containingFile, compilerOptions, tsSys).resolvedModule;
         if (tsResolvedModule) {
             if (isDeclarationFileExtension(tsResolvedModule.extension)) {
                 const srcFilePath = toSourceFilePath(tsResolvedModule.resolvedFileName);

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/Performance.js

@@ -8,7 +8,7 @@ const { values } = parseArgs({
     strict: false,
     options: {
         performance: { type: 'boolean' },
-        'performance-fn': { type: 'string' },
+        'performance-fn': { type: 'string', multiple: true },
         memory: { type: 'boolean' },
         'memory-realtime': { type: 'boolean' },
     },
@@ -20,7 +20,7 @@ const isMemoryUsageEnabled = !!values.memory || isMemoryRealtime;
 export const timerify = (fn, name = fn.name) => {
     if (!isTimerifyFunctions)
         return fn;
-    if (timerifyOnlyFnName && name !== timerifyOnlyFnName)
+    if (timerifyOnlyFnName && !timerifyOnlyFnName.includes(name))
         return fn;
     return performance.timerify(Object.defineProperty(fn, 'name', { get: () => name }));
 };
@@ -123,10 +123,12 @@ class Performance {
     }
     getMemoryUsageTable() {
         const table = new Table({ header: true });
+        let i = 0;
         for (const entry of this.memEntries) {
             if (!entry.detail)
                 continue;
             table.row();
+            table.cell('#', String(i++));
             table.cell('heapUsed', inMB(entry.detail.heapUsed), twoFixed);
             table.cell('heapTotal', inMB(entry.detail.heapTotal), twoFixed);
             table.cell('freemem', inMB(entry.detail.freemem), twoFixed);

package/dist/util/create-options.d.ts

@@ -516,6 +516,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        svgr?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         syncpack?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1112,6 +1117,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            svgr?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             syncpack?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;

package/dist/util/create-options.js

@@ -45,6 +45,8 @@ export const createOptions = async (options) => {
             : []);
     const isStrict = options.isStrict ?? parsedCLIArgs.strict ?? false;
     const isProduction = options.isProduction ?? parsedCLIArgs.production ?? isStrict;
+    const isDebug = parsedCLIArgs.debug ?? false;
+    const isTrace = Boolean(parsedCLIArgs.trace ?? parsedCLIArgs['trace-file'] ?? parsedCLIArgs['trace-export']);
     const rules = { ...defaultRules, ...parsedConfig.rules };
     const excludesFromRules = getKeysByValue(rules, 'off');
     const includedIssueTypes = getIncludedIssueTypes({
@@ -82,7 +84,7 @@ export const createOptions = async (options) => {
         gitignore: parsedCLIArgs['no-gitignore'] ? false : (options.gitignore ?? true),
         includedIssueTypes,
         isCache: parsedCLIArgs.cache ?? false,
-        isDebug: parsedCLIArgs.debug ?? false,
+        isDebug,
         isDisableConfigHints: parsedCLIArgs['no-config-hints'] || isProduction || Boolean(parsedCLIArgs.workspace),
         isFix: parsedCLIArgs.fix ?? options.isFix ?? isFixFiles ?? fixTypes.length > 0,
         isFixCatalog: fixTypes.length === 0 || fixTypes.includes('catalog'),
@@ -101,13 +103,15 @@ export const createOptions = async (options) => {
             includedIssueTypes.binaries,
         isReportTypes: includedIssueTypes.types || includedIssueTypes.nsTypes || includedIssueTypes.enumMembers,
         isReportValues: includedIssueTypes.exports || includedIssueTypes.nsExports || isReportClassMembers,
-        isShowProgress: parsedCLIArgs['no-progress'] !== true &&
+        isShowProgress: !isDebug &&
+            !isTrace &&
+            parsedCLIArgs['no-progress'] !== true &&
             options.isShowProgress !== false &&
             process.stdout.isTTY &&
             typeof process.stdout.cursorTo === 'function',
         isSkipLibs: !(isIncludeLibs || includedIssueTypes.classMembers),
         isStrict,
-        isTrace: Boolean(parsedCLIArgs.trace ?? parsedCLIArgs['trace-file'] ?? parsedCLIArgs['trace-export']),
+        isTrace,
         isTreatConfigHintsAsErrors: parsedCLIArgs['treat-config-hints-as-errors'] ?? parsedConfig.treatConfigHintsAsErrors ?? false,
         isWatch: parsedCLIArgs.watch ?? options.isWatch ?? false,
         maxShowIssues: parsedCLIArgs['max-show-issues'] ? Number(parsedCLIArgs['max-show-issues']) : undefined,
@@ -115,7 +119,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);
@@ -40,7 +40,6 @@ const createFileNode = () => ({
     exports: new Map(),
     duplicates: new Set(),
     scripts: new Set(),
-    traceRefs: new Set(),
 });
 export const createImports = () => ({
     refs: new Set(),

package/dist/util/resolve.d.ts

@@ -1,4 +1,5 @@
-declare const createSyncResolver: (extensions: string[]) => (specifier: string, baseDir: string) => string | undefined;
+declare const createSyncModuleResolver: (extensions: string[]) => (specifier: string, basePath: string) => string | undefined;
+export declare const _resolveModuleSync: (specifier: string, basePath: string) => string | undefined;
+export declare const _createSyncModuleResolver: typeof createSyncModuleResolver;
 export declare const _resolveSync: (specifier: string, baseDir: string) => string | undefined;
-export declare const _createSyncResolver: typeof createSyncResolver;
 export {};

package/dist/util/resolve.js

@@ -2,6 +2,30 @@ import { ResolverFactory } from 'oxc-resolver';
 import { DEFAULT_EXTENSIONS } from '../constants.js';
 import { timerify } from './Performance.js';
 import { toPosix } from './path.js';
+const createSyncModuleResolver = (extensions) => {
+    const resolver = new ResolverFactory({
+        tsconfig: 'auto',
+        extensions,
+        extensionAlias: {
+            '.js': ['.js', '.ts'],
+            '.jsx': ['.jsx', '.tsx'],
+            '.mjs': ['.mjs', '.mts'],
+            '.cjs': ['.cjs', '.cts'],
+        },
+        conditionNames: ['require', 'import', 'node', 'default'],
+    });
+    return function resolveSync(specifier, basePath) {
+        try {
+            const resolved = resolver.resolveFileSync(basePath, specifier);
+            if (resolved?.path)
+                return toPosix(resolved.path);
+        }
+        catch (_error) { }
+    };
+};
+const resolveModuleSync = createSyncModuleResolver([...DEFAULT_EXTENSIONS, '.json', '.jsonc']);
+export const _resolveModuleSync = timerify(resolveModuleSync);
+export const _createSyncModuleResolver = extensions => timerify(createSyncModuleResolver(extensions));
 const createSyncResolver = (extensions) => {
     const resolver = new ResolverFactory({
         extensions,
@@ -16,6 +40,5 @@ const createSyncResolver = (extensions) => {
         catch (_error) { }
     };
 };
-const resolveSync = createSyncResolver([...DEFAULT_EXTENSIONS, '.json', '.jsonc']);
+const resolveSync = createSyncResolver(DEFAULT_EXTENSIONS);
 export const _resolveSync = timerify(resolveSync);
-export const _createSyncResolver = extensions => timerify(createSyncResolver(extensions));

package/dist/util/trace.d.ts

@@ -1,20 +1,2 @@
-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 = {
-    filePath: string;
-    identifier?: string;
-    hasRef: boolean;
-    isEntry: boolean;
-    children: Set<TraceNode>;
-};
-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 {};
+import type { TreeNode } from '../graph-explorer/operations/build-exports-tree.js';
+export declare const formatTrace: (node: TreeNode, toRelative: (path: string) => string, isReferenced: boolean) => string;

package/dist/util/trace.js

@@ -1,70 +1,45 @@
-import picocolors from 'picocolors';
-import { toAbsolute, toRelative } from './path.js';
-const IS_ENTRY = ' ◯';
-const HAS_REF = ' ✓';
-const HAS_NO_REF = ' x';
-const getPadding = (level, levels) => {
-    let padding = '';
-    for (let i = 0; i < level; i++)
-        padding += levels.has(i) ? `${picocolors.dim('│')}  ` : '   ';
-    return padding;
-};
-const renderTrace = (node, options, level = 0, levels = new Set()) => {
-    let index = 0;
-    const size = node.children.size;
-    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 text = `${padding}${picocolors.dim(isLast ? '└─' : '├─')} ${file}${suffix}`;
-        console.log(text);
-        if (child.children.size > 0) {
-            if (!isLast)
-                levels.add(level);
-            if (isLast)
-                levels.delete(level);
-            renderTrace(child, options, level + 1, levels);
+import pc from 'picocolors';
+export const formatTrace = (node, toRelative, isReferenced) => {
+    const lines = [];
+    const file = pc.white;
+    const id = pc.cyanBright;
+    const ref = pc.cyanBright;
+    const via = pc.dim;
+    const ok = pc.green;
+    const fail = pc.red;
+    const dim = pc.dim;
+    const entryMarker = node.isEntry ? dim(' ◯') : '';
+    lines.push(`${file(toRelative(node.filePath))}${dim(':')}${id(node.identifier)}${entryMarker}`);
+    const formatVia = (child) => {
+        if (!child.via)
+            return id(child.identifier);
+        const parts = child.identifier.split('.');
+        const name = parts[0];
+        const rest = parts.slice(1).join('.');
+        const nameDisplay = child.originalId ? `${id(child.originalId)}${dim(' → ')}${id(name)}` : id(name);
+        return `${via(child.via)}${dim('[')}${nameDisplay}${rest ? `${dim('.')}${id(rest)}` : ''}${dim(']')}`;
+    };
+    const formatChild = (child, prefix, isLast) => {
+        const connector = isLast ? '└── ' : '├── ';
+        const childPrefix = isLast ? '    ' : '│   ';
+        const entryMarker = child.isEntry ? dim(' ◯') : '';
+        const isLeaf = child.children.length === 0;
+        const leafMarker = isLeaf && !child.via?.startsWith('reExport') ? (isReferenced ? ok(' ✓') : fail(' ✗')) : '';
+        lines.push(`${dim(prefix)}${dim(connector)}${file(toRelative(child.filePath))}${dim(':')}${formatVia(child)}${entryMarker}${leafMarker}`);
+        if (child.refs.length > 0) {
+            const refsPrefix = isLeaf ? ' ' : '│';
+            lines.push(`${dim(prefix)}${dim(childPrefix)}${dim(refsPrefix)} ${dim('refs: [')}${child.refs.map(r => ref(r)).join(dim(', '))}${dim(']')}`);
+        }
+        for (let i = 0; i < child.children.length; i++) {
+            formatChild(child.children[i], prefix + childPrefix, i === child.children.length - 1);
         }
+    };
+    for (let i = 0; i < node.children.length; i++) {
+        formatChild(node.children[i], '', i === node.children.length - 1);
     }
-};
-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}`;
-    console.log(header);
-    renderTrace(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)) });
+    if (node.children.length === 0) {
+        const leafMarker = isReferenced ? ok(' ✓') : fail(' ✗');
+        lines.push(`${dim('└── (no imports found)')}${leafMarker}`);
     }
-};
-export const createAndPrintTrace = (filePath, options, opts = {}) => {
-    if (!options.isTrace)
-        return;
-    const traceNode = createNode(filePath, opts);
-    printTrace(traceNode, filePath, options, opts.identifier);
+    return lines.join('\n');
 };

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 {};