knip 6.33.0 → 6.34.0

package/dist/ProjectPrincipal.d.ts

@@ -1,6 +1,6 @@
 import type { ParseResult } from 'oxc-parser';
 import { CacheConsultant } from './CacheConsultant.ts';
-import type { AsyncCompilers, SyncCompilers } from './compilers/types.ts';
+import type { AsyncCompilers, Compilers, SyncCompilers } from './compilers/types.ts';
 import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile, PluginVisitorContext, PluginVisitorObject } from './types/config.ts';
 import type { FileNode, ModuleGraph } from './types/module-graph.ts';
 import type { Paths } from './types/project.ts';
@@ -19,6 +19,8 @@ export declare class ProjectPrincipal {
     private _localRefsVisitor;
     syncCompilers: SyncCompilers;
     asyncCompilers: AsyncCompilers;
+    private scopedSyncCompilers;
+    private scopedAsyncCompilers;
     private paths;
     private rootDirs;
     private tsConfigFile;
@@ -26,14 +28,15 @@ export declare class ProjectPrincipal {
     cache: CacheConsultant<FileNode>;
     toSourceFilePath: ToSourceFilePath;
     private findWorkspacePackageTarget;
+    private findWorkspaceNameByFilePath;
     fileManager: SourceFileManager;
     private resolveModule;
     resolveGlobPattern: ResolveGlobPattern;
     resolvedFiles: Set<string>;
     deletedFiles: Set<string>;
     private onPathAdded;
-    constructor(options: MainOptions, toSourceFilePath: ToSourceFilePath, findWorkspacePackageTarget?: WorkspacePackageTargetHandler);
-    addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;
+    constructor(options: MainOptions, toSourceFilePath: ToSourceFilePath, findWorkspacePackageTarget: WorkspacePackageTargetHandler | undefined, findWorkspaceNameByFilePath: (filePath: string) => string | undefined);
+    addCompilers(workspaceName: string, compilers: Compilers): void;
     addPaths(paths: Paths, basePath: string, scope: string): void;
     addRootDirs(rootDirs: string[] | undefined, scope: string): void;
     init(): void;

package/dist/ProjectPrincipal.js

@@ -30,6 +30,8 @@ export class ProjectPrincipal {
     _localRefsVisitor;
     syncCompilers = new Map();
     asyncCompilers = new Map();
+    scopedSyncCompilers = new Map();
+    scopedAsyncCompilers = new Map();
     paths = new Map();
     rootDirs = new Map();
     tsConfigFile;
@@ -37,16 +39,18 @@ export class ProjectPrincipal {
     cache;
     toSourceFilePath;
     findWorkspacePackageTarget;
+    findWorkspaceNameByFilePath;
     fileManager;
     resolveModule = () => undefined;
     resolveGlobPattern = pattern => [pattern];
     resolvedFiles = new Set();
     deletedFiles = new Set();
     onPathAdded;
-    constructor(options, toSourceFilePath, findWorkspacePackageTarget) {
+    constructor(options, toSourceFilePath, findWorkspacePackageTarget, findWorkspaceNameByFilePath) {
         this.cache = new CacheConsultant('root', options);
         this.toSourceFilePath = toSourceFilePath;
         this.findWorkspacePackageTarget = findWorkspacePackageTarget;
+        this.findWorkspaceNameByFilePath = findWorkspaceNameByFilePath;
         this.tsConfigFile = options.tsConfigFile ? toAbsolute(options.tsConfigFile, options.cwd) : undefined;
         this.pluginVisitorObjects.push(createBunShellVisitor(this.pluginCtx));
         this.fileManager = new SourceFileManager({
@@ -54,16 +58,34 @@ export class ProjectPrincipal {
         });
         this.walkAndAnalyze = timerify(this.walkAndAnalyze.bind(this), 'walkAndAnalyze');
     }
-    addCompilers(compilers) {
+    addCompilers(workspaceName, compilers) {
         for (const [ext, compiler] of compilers[0]) {
-            if (!this.syncCompilers.has(ext)) {
-                this.syncCompilers.set(ext, compiler);
+            const workspaceCompilers = this.scopedSyncCompilers.get(ext);
+            if (workspaceCompilers) {
+                workspaceCompilers.set(workspaceName, compiler);
+            }
+            else {
+                const workspaceCompilers = new Map([[workspaceName, compiler]]);
+                this.scopedSyncCompilers.set(ext, workspaceCompilers);
+                this.syncCompilers.set(ext, (source, filePath) => {
+                    const owner = this.findWorkspaceNameByFilePath(filePath);
+                    return ((owner ? workspaceCompilers.get(owner) : undefined) ?? compiler)(source, filePath);
+                });
                 this.extensions.add(ext);
             }
         }
         for (const [ext, compiler] of compilers[1]) {
-            if (!this.asyncCompilers.has(ext)) {
-                this.asyncCompilers.set(ext, compiler);
+            const workspaceCompilers = this.scopedAsyncCompilers.get(ext);
+            if (workspaceCompilers) {
+                workspaceCompilers.set(workspaceName, compiler);
+            }
+            else {
+                const workspaceCompilers = new Map([[workspaceName, compiler]]);
+                this.scopedAsyncCompilers.set(ext, workspaceCompilers);
+                this.asyncCompilers.set(ext, (source, filePath) => {
+                    const owner = this.findWorkspaceNameByFilePath(filePath);
+                    return ((owner ? workspaceCompilers.get(owner) : undefined) ?? compiler)(source, filePath);
+                });
                 this.extensions.add(ext);
             }
         }

package/dist/cli.js

@@ -51,7 +51,7 @@ const main = async () => {
             isShowProgress: options.isShowProgress,
             isTreatConfigHintsAsErrors: options.isTreatConfigHintsAsErrors,
             isTreatTagHintsAsErrors: options.isTreatTagHintsAsErrors,
-            maxShowIssues: args['max-show-issues'] ? Number(args['max-show-issues']) : undefined,
+            maxShowIssues: options.maxShowIssues,
             options: args['reporter-options'] ?? '',
             preprocessorOptions: args['preprocessor-options'] ?? '',
             selectedWorkspaces,
@@ -75,7 +75,7 @@ const main = async () => {
             perfObserver.reset();
         }
         if (!args['no-exit-code'] &&
-            (totalErrorCount > Number(args['max-issues'] ?? 0) ||
+            (totalErrorCount > options.maxIssues ||
                 (!options.isDisableConfigHints && options.isTreatConfigHintsAsErrors && configurationHints.length > 0) ||
                 (!options.isDisableTagHints && options.isTreatTagHintsAsErrors && tagHints.size > 0))) {
             process.exitCode = 1;

package/dist/graph/analyze.js

@@ -191,7 +191,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                         }
                     }
                 }
-                if (file.imports?.external) {
+                if (file.imports.external) {
                     for (const extImport of file.imports.external) {
                         const packageName = getPackageNameFromModuleSpecifier(extImport.specifier);
                         const isHandled = packageName &&
@@ -200,7 +200,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                 isTypeOnly: extImport.isTypeOnly,
                                 isResolved: extImport.filePath !== undefined,
                             });
-                        if (!isHandled)
+                        if (!isHandled && !(extImport.jsDocTags?.size && shouldIgnoreTags(extImport.jsDocTags)))
                             collector.addIssue({
                                 type: 'unlisted',
                                 filePath,
@@ -214,7 +214,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                             });
                     }
                 }
-                if (file.imports?.unresolved) {
+                if (file.imports.unresolved) {
                     for (const unresolvedImport of file.imports.unresolved) {
                         const { specifier, pos, line, col } = unresolvedImport;
                         collector.addIssue({

package/dist/graph/build.js

@@ -90,7 +90,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             compilers[0].set(ext, compiler);
         };
         await worker.registerCompilers(registerCompiler);
-        principal.addCompilers(compilers);
+        principal.addCompilers(name, compilers);
         const extensions = getCompilerExtensions(compilers);
         const extensionGlobStr = `.{${[...DEFAULT_EXTENSIONS, ...extensions].map(ext => ext.slice(1)).join(',')}}`;
         const config = chief.getConfigForWorkspace(name, extensions);

package/dist/plugins/node/index.js

@@ -1,5 +1,6 @@
 import { toEntry, toProductionEntry } from '../../util/input.js';
 import { getScriptCommands } from '../../util/scripts.js';
+import { createFsPromisesGlobVisitor } from './visitors/fsPromisesGlob.js';
 const title = 'Node.js';
 const isEnabled = () => true;
 const patterns = [
@@ -21,6 +22,9 @@ const hasNodeTest = (scripts) => {
     return result;
 };
 const entry = ['server.js'];
+const registerVisitors = ({ ctx, registerVisitor }) => {
+    registerVisitor(createFsPromisesGlobVisitor(ctx));
+};
 const resolve = options => {
     const entries = entry.map(id => toProductionEntry(id));
     if (hasNodeTest(options.manifest.scripts) || hasNodeTest(options.rootManifest?.scripts)) {
@@ -53,5 +57,6 @@ const plugin = {
     entry,
     resolve,
     args,
+    registerVisitors,
 };
 export default plugin;

package/dist/plugins/node/visitors/fsPromisesGlob.d.ts

@@ -0,0 +1,2 @@
+import type { PluginVisitorContext, PluginVisitorObject } from '../../../types/config.ts';
+export declare function createFsPromisesGlobVisitor(ctx: PluginVisitorContext): PluginVisitorObject;

package/dist/plugins/node/visitors/fsPromisesGlob.js

@@ -0,0 +1,89 @@
+import { findProperty, getPropertyKey } from '../../../typescript/ast-helpers.js';
+import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
+const FS_PROMISES = new Set(['node:fs/promises', 'fs/promises']);
+export function createFsPromisesGlobVisitor(ctx) {
+    const globNames = new Set();
+    const namespaceNames = new Set();
+    return {
+        Program() {
+            globNames.clear();
+            namespaceNames.clear();
+        },
+        ImportDeclaration(node) {
+            if (!FS_PROMISES.has(node.source.value))
+                return;
+            for (const specifier of node.specifiers ?? []) {
+                if (specifier.type === 'ImportNamespaceSpecifier') {
+                    namespaceNames.add(specifier.local.name);
+                }
+                else if (specifier.type === 'ImportSpecifier' &&
+                    specifier.imported.type === 'Identifier' &&
+                    specifier.imported.name === 'glob') {
+                    globNames.add(specifier.local.name);
+                }
+            }
+        },
+        VariableDeclarator(node) {
+            if (node.init?.type !== 'CallExpression' ||
+                node.init.callee.type !== 'Identifier' ||
+                node.init.callee.name !== 'require' ||
+                !isStringLiteral(node.init.arguments[0]) ||
+                !FS_PROMISES.has(getStringValue(node.init.arguments[0])))
+                return;
+            if (node.id.type === 'Identifier') {
+                namespaceNames.add(node.id.name);
+            }
+            else if (node.id.type === 'ObjectPattern') {
+                for (const property of node.id.properties) {
+                    if (property.type === 'Property' &&
+                        getPropertyKey(property) === 'glob' &&
+                        property.value.type === 'Identifier') {
+                        globNames.add(property.value.name);
+                    }
+                }
+            }
+        },
+        CallExpression(node) {
+            let isGlobCall = node.callee.type === 'Identifier' && globNames.has(node.callee.name);
+            if (!isGlobCall &&
+                node.callee.type === 'MemberExpression' &&
+                !node.callee.computed &&
+                node.callee.object.type === 'Identifier' &&
+                namespaceNames.has(node.callee.object.name) &&
+                node.callee.property.type === 'Identifier' &&
+                node.callee.property.name === 'glob') {
+                isGlobCall = true;
+            }
+            if (!isGlobCall)
+                return;
+            const arg = node.arguments[0];
+            if (!arg)
+                return;
+            let patterns;
+            if (isStringLiteral(arg)) {
+                patterns = [getStringValue(arg)];
+            }
+            else if (arg.type === 'ArrayExpression') {
+                patterns = [];
+                for (const element of arg.elements) {
+                    if (!element || !isStringLiteral(element))
+                        return;
+                    patterns.push(getStringValue(element));
+                }
+            }
+            if (!patterns?.length || patterns.some(pattern => pattern.startsWith('!')))
+                return;
+            const options = node.arguments[1];
+            if (options && options.type !== 'ObjectExpression')
+                return;
+            if (options &&
+                (options.properties.length > 1 ||
+                    options.properties.some(property => property.type !== 'Property' || property.computed || getPropertyKey(property) !== 'cwd')))
+                return;
+            const cwdNode = findProperty(options, 'cwd');
+            if (cwdNode && !isStringLiteral(cwdNode))
+                return;
+            ctx.addImportGlob(patterns, { cwd: cwdNode ? getStringValue(cwdNode) : '.' });
+        },
+    };
+}

package/dist/plugins/nuxt/index.js

@@ -87,18 +87,18 @@ const addAppEntries = (inputs, srcDir, serverDir, config, dir) => {
             inputs.push(toDeferResolveProductionEntry(resolveAlias(id, srcDir, dir)));
 };
 const findLayerConfigs = (cwd) => _syncGlob({ cwd, patterns: [`layers/*/${config.at(0)}`] });
+const definitionFiles = [
+    '.nuxt/imports.d.ts',
+    '.nuxt/components.d.ts',
+    '.nuxt/types/nitro-routes.d.ts',
+    '.nuxt/types/nitro-imports.d.ts',
+];
 const registerCompilers = async ({ cwd, hasDependency, registerCompiler }) => {
-    if (hasDependency('nuxt') || hasDependency('nuxt-nightly')) {
+    if (hasDependency('nuxt') || hasDependency('nuxt-nightly') || isDirectory(cwd, '.nuxt')) {
+        const paths = definitionFiles.map(file => join(cwd, file));
         const maps = createAutoImportMaps();
-        const definitionFiles = [
-            '.nuxt/imports.d.ts',
-            '.nuxt/components.d.ts',
-            '.nuxt/types/nitro-routes.d.ts',
-            '.nuxt/types/nitro-imports.d.ts',
-        ];
-        for (const file of definitionFiles) {
-            const path = join(cwd, file);
-            buildAutoImportMap(path, readAndParseFile(path), maps, file.endsWith('components.d.ts'));
+        for (const path of paths) {
+            buildAutoImportMap(path, readAndParseFile(path), maps, path.endsWith('components.d.ts'));
         }
         registerCompiler({ extension: '.vue', compiler: createVueCompiler(maps, cwd) });
         registerCompiler({ extension: '.ts', compiler: createTsCompiler(maps) });
@@ -121,6 +121,9 @@ const resolveConfig = async (localConfig, options) => {
             addModule(id);
     }
     addAppEntries(inputs, srcDir, serverDir, localConfig, cwd);
+    const sharedDir = toAbsolute(localConfig.dir?.shared ?? 'shared', cwd);
+    inputs.push(toAlias('#shared', sharedDir));
+    inputs.push(toAlias('#shared/*', join(sharedDir, '*'), { dir: cwd }));
     const aliases = localConfig.alias;
     if (aliases) {
         for (const key in aliases) {

package/dist/run.js

@@ -60,7 +60,7 @@ export const run = async (options) => {
     const isGitIgnored = await getGitIgnoredHandler(options, new Set(workspaces.map(w => w.dir)));
     const toSourceFilePath = getModuleSourcePathHandler(chief);
     const findWorkspacePackageTarget = getWorkspacePackageTargetHandler(chief);
-    const principal = new ProjectPrincipal(options, toSourceFilePath, findWorkspacePackageTarget);
+    const principal = new ProjectPrincipal(options, toSourceFilePath, findWorkspacePackageTarget, filePath => chief.findWorkspaceByFilePath(filePath)?.name);
     collector.setWorkspaceFilter(chief.workspaceFilePathFilter);
     collector.setSelectedWorkspaces(chief.selectedWorkspaces);
     collector.setIgnoreIssues(chief.getIgnoreIssues());

package/dist/types/config.d.ts

@@ -141,6 +141,7 @@ export type PluginVisitorContext = {
     markImportExpressionHandled: (pos: number) => void;
     addImportGlob: (patterns: string[], options?: {
         base?: string;
+        cwd?: string;
         filter?: RegExp;
     }) => void;
     markExportRegistered: (name: string) => void;

package/dist/types/module-graph.d.ts

@@ -30,6 +30,7 @@ export interface Import extends Position {
     readonly identifier: string | undefined;
     readonly isTypeOnly: boolean;
     readonly modifiers: number;
+    readonly jsDocTags: Tags | undefined;
 }
 export interface ExternalRef {
     readonly specifier: string;
@@ -76,6 +77,7 @@ export type FileNode = {
 export interface ImportGlob {
     patterns: string[];
     base?: string;
+    cwd?: string;
     filter?: RegExp;
 }
 export type ModuleGraph = Map<FilePath, FileNode>;

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

@@ -62,6 +62,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
             col: opts.col,
             isTypeOnly: isDts || !!(modifiers & IMPORT_FLAGS.TYPE_ONLY),
             modifiers,
+            jsDocTags: undefined,
         });
         const file = internal.get(importFilePath);
         const importMaps = file ?? createImports();
@@ -146,6 +147,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
                         col,
                         isTypeOnly: isDts || !!(modifiers & IMPORT_FLAGS.TYPE_ONLY),
                         modifiers,
+                        jsDocTags,
                     });
                 }
             }
@@ -171,6 +173,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
                     col,
                     isTypeOnly: isDts || !!(modifiers & IMPORT_FLAGS.TYPE_ONLY),
                     modifiers,
+                    jsDocTags: undefined,
                 });
             }
         }
@@ -280,7 +283,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         pluginCtx.addScript = (s) => scripts.add(s);
         pluginCtx.addImport = (spec, pos, mod) => addImport(spec, undefined, undefined, undefined, pos, mod);
         pluginCtx.markImportExpressionHandled = (pos) => handledImportExpressions.add(pos);
-        pluginCtx.addImportGlob = (patterns, opts) => importGlobs.push({ patterns, base: opts?.base, filter: opts?.filter });
+        pluginCtx.addImportGlob = (patterns, opts) => importGlobs.push({ patterns, base: opts?.base, cwd: opts?.cwd, filter: opts?.filter });
         pluginCtx.markExportRegistered = (name) => registeredCustomElements.add(name);
     }
     const localRefs = _walkAST(result.program, sourceText, filePath, result.module.hasModuleSyntax, {

package/dist/typescript/glob-imports.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 import { _syncGlob } from '../util/glob.js';
-import { dirname, isAbsolute, join, toRelative } from '../util/path.js';
+import { dirname, isAbsolute, join, toAbsolute, toRelative } from '../util/path.js';
 function resolveBaseDir(base, dir, resolveGlobPattern) {
     if (base.startsWith('.'))
         return join(dir, base);
@@ -15,8 +15,13 @@ function resolveBaseDir(base, dir, resolveGlobPattern) {
 export function resolveImportGlobs(items, containingFile, resolveGlobPattern, workspaceRoot) {
     const filePaths = [];
     const dir = dirname(containingFile);
-    for (const { patterns, base, filter } of items) {
-        if (base !== undefined) {
+    for (const { patterns, base, cwd, filter } of items) {
+        if (cwd !== undefined) {
+            for (const filePath of _syncGlob({ patterns, cwd: toAbsolute(cwd, workspaceRoot) })) {
+                filePaths.push(filePath);
+            }
+        }
+        else if (base !== undefined) {
             const cwd = resolveBaseDir(base, dir, resolveGlobPattern);
             if (!cwd)
                 continue;

package/dist/typescript/visitors/calls.js

@@ -256,7 +256,7 @@ export function handleNewExpression(node, s) {
         node.arguments[1].property.name === 'url') {
         const specifier = getStringValue(node.arguments[0]);
         if (specifier)
-            s.addImport(specifier, undefined, undefined, undefined, node.arguments[0].start, IMPORT_FLAGS.ENTRY | IMPORT_FLAGS.OPTIONAL);
+            s.addImport(specifier, undefined, undefined, undefined, node.arguments[0].start, IMPORT_FLAGS.ENTRY | IMPORT_FLAGS.OPTIONAL, undefined, s.getJSDocTags(node.start));
         return;
     }
     if (s.hasWorkerThreadsImport &&

package/dist/typescript/visitors/walk.d.ts

@@ -1,4 +1,4 @@
-import { Visitor, type Class, type Function as FunctionNode, type Program, type Span, type VariableDeclarator } from 'oxc-parser';
+import { Visitor, type Class, type Function as FunctionNode, type Program, type Span, type TSInterfaceDeclaration, type VariableDeclarator } from 'oxc-parser';
 import type { PluginVisitorObject } from '../../types/config.ts';
 import type { GetImportsAndExportsOptions } from '../../types/config.ts';
 import type { Fix } from '../../types/exports.ts';
@@ -67,10 +67,12 @@ export interface WalkState extends WalkContext {
     scopeEnds: number[];
     shadowScopes: Map<string, [number, number][]>;
     localDeclarations: Map<string, FunctionNode | Class | VariableDeclarator>;
+    localInterfaces: Map<string, TSInterfaceDeclaration | null>;
     pendingCallRefs: Array<{
         name: string;
         exportName: string;
         seen: Set<string>;
+        kind: 'callee' | 'argument';
     }>;
     pendingMemberCallRefs: Array<{
         objectName: string;

package/dist/typescript/visitors/walk.js

@@ -49,7 +49,7 @@ const _addExport = (identifier, type, pos, members, fix, isReExport, jsDocTags)
         });
     }
 };
-const _collectRefsInType = (node, exportName, signatureOnly, seen = new Set(), inBody = false) => {
+const _collectRefsInType = (node, exportName, signatureOnly, seen = new Set(), inBody = false, thisType) => {
     if (!node)
         return;
     const type = node.type;
@@ -64,10 +64,14 @@ const _collectRefsInType = (node, exportName, signatureOnly, seen = new Set(), i
             if (node.typeName?.type === 'Identifier')
                 _addRefInExport(node.typeName.name, exportName);
             break;
+        case 'TSThisType':
+            if (thisType)
+                _addRefInExport(thisType, exportName);
+            return;
         case 'CallExpression': {
             const callee = node.callee;
             if (callee?.type === 'Identifier') {
-                state.pendingCallRefs.push({ name: callee.name, exportName, seen });
+                state.pendingCallRefs.push({ name: callee.name, exportName, seen, kind: 'callee' });
             }
             else if (callee?.type === 'MemberExpression' &&
                 !callee.computed &&
@@ -84,8 +88,9 @@ const _collectRefsInType = (node, exportName, signatureOnly, seen = new Set(), i
                 const args = node.arguments;
                 if (args) {
                     for (const arg of args) {
-                        if (arg?.type === 'Identifier')
-                            state.pendingCallRefs.push({ name: arg.name, exportName, seen });
+                        if (arg?.type === 'Identifier') {
+                            state.pendingCallRefs.push({ name: arg.name, exportName, seen, kind: 'argument' });
+                        }
                     }
                 }
             }
@@ -101,14 +106,14 @@ const _collectRefsInType = (node, exportName, signatureOnly, seen = new Set(), i
         case 'TSSatisfiesExpression':
             if (inBody) {
                 if (node.expression)
-                    _collectRefsInType(node.expression, exportName, signatureOnly, seen, inBody);
+                    _collectRefsInType(node.expression, exportName, signatureOnly, seen, inBody, thisType);
                 return;
             }
             break;
         case 'VariableDeclarator':
             if (inBody) {
                 if (node.init)
-                    _collectRefsInType(node.init, exportName, signatureOnly, seen, inBody);
+                    _collectRefsInType(node.init, exportName, signatureOnly, seen, inBody, thisType);
                 return;
             }
             break;
@@ -124,14 +129,63 @@ const _collectRefsInType = (node, exportName, signatureOnly, seen = new Set(), i
         if (Array.isArray(val)) {
             for (const item of val) {
                 if (item)
-                    _collectRefsInType(item, exportName, signatureOnly, seen, childInBody);
+                    _collectRefsInType(item, exportName, signatureOnly, seen, childInBody, thisType);
             }
         }
         else {
-            _collectRefsInType(val, exportName, signatureOnly, seen, childInBody);
+            _collectRefsInType(val, exportName, signatureOnly, seen, childInBody, thisType);
         }
     }
 };
+const _collectRefsInDirectMemberResult = (fn, exportName, seen) => {
+    const body = fn.body;
+    if (body?.type !== 'MemberExpression' ||
+        body.computed ||
+        body.object?.type !== 'Identifier' ||
+        body.property?.type !== 'Identifier') {
+        return false;
+    }
+    const params = Array.isArray(fn.params) ? fn.params : (fn.params?.items ?? []);
+    const param = params.find((param) => param.type === 'Identifier' && param.name === body.object.name);
+    const paramType = param?.typeAnnotation?.typeAnnotation;
+    if (paramType?.type !== 'TSTypeReference' || paramType.typeName?.type !== 'Identifier' || paramType.typeArguments) {
+        return false;
+    }
+    const declaration = state.localInterfaces.get(paramType.typeName.name);
+    if (!declaration || declaration.typeParameters)
+        return false;
+    const members = declaration.body.body.filter((member) => member.type === 'TSPropertySignature' &&
+        !member.computed &&
+        member.key?.type === 'Identifier' &&
+        member.key.name === body.property.name &&
+        Boolean(member.typeAnnotation));
+    if (members.length !== 1)
+        return false;
+    _collectRefsInType(members[0].typeAnnotation, exportName, true, seen, false, paramType.typeName.name);
+    return true;
+};
+const _collectRefsInCallResult = (node, exportName, seen) => {
+    const annotatedType = node.type === 'VariableDeclarator' ? node.id.typeAnnotation?.typeAnnotation : undefined;
+    if (annotatedType?.type === 'TSFunctionType') {
+        _collectRefsInType(annotatedType.typeParameters, exportName, true, seen);
+        return _collectRefsInType(annotatedType.returnType, exportName, true, seen);
+    }
+    if (annotatedType)
+        return _collectRefsInType(annotatedType, exportName, true, seen);
+    const fn = node.type === 'VariableDeclarator' ? node.init : node;
+    if (fn?.type !== 'ArrowFunctionExpression' &&
+        fn?.type !== 'FunctionDeclaration' &&
+        fn?.type !== 'FunctionExpression') {
+        return _collectRefsInType(node, exportName, true, seen);
+    }
+    if (fn.returnType) {
+        _collectRefsInType(fn.typeParameters, exportName, true, seen);
+        return _collectRefsInType(fn.returnType, exportName, true, seen);
+    }
+    if (_collectRefsInDirectMemberResult(fn, exportName, seen))
+        return;
+    _collectRefsInType(fn, exportName, true, seen);
+};
 const _addRefInExport = (name, exportName) => {
     const refs = state.referencedInExport.get(name);
     if (refs)
@@ -221,6 +275,12 @@ const coreVisitorObject = {
                 state.addImport(specifier, name, undefined, undefined, node.id.start, IMPORT_FLAGS.TYPE_ONLY | IMPORT_FLAGS.AUGMENT);
         }
     },
+    TSInterfaceDeclaration(node) {
+        if (state.scopeDepth > 0 || state.isInNamespace(node))
+            return;
+        const name = node.id.name;
+        state.localInterfaces.set(name, state.localInterfaces.has(name) ? null : node);
+    },
     ClassDeclaration(node) {
         state.classNameStack.push(node.id?.name ?? '');
         if (node.id?.name) {
@@ -740,6 +800,7 @@ function walkAST(program, sourceText, filePath, hasModuleSyntax, ctx) {
         scopeEnds: [],
         shadowScopes: new Map(),
         localDeclarations: new Map(),
+        localInterfaces: new Map(),
         pendingCallRefs: [],
         pendingMemberCallRefs: [],
         localToExports: new Map(),
@@ -756,14 +817,18 @@ function walkAST(program, sourceText, filePath, hasModuleSyntax, ctx) {
     ctx.visitor.visit(program);
     while (state.pendingCallRefs.length > 0 || state.pendingMemberCallRefs.length > 0) {
         while (state.pendingCallRefs.length > 0) {
-            const { name, exportName, seen } = state.pendingCallRefs.pop();
-            if (seen.has(name))
+            const { name, exportName, seen, kind } = state.pendingCallRefs.pop();
+            const key = `${kind}:${name}`;
+            if (seen.has(key))
                 continue;
             const decl = state.localDeclarations.get(name);
             if (!decl)
                 continue;
-            seen.add(name);
-            _collectRefsInType(decl, exportName, true, seen);
+            seen.add(key);
+            if (kind === 'callee')
+                _collectRefsInCallResult(decl, exportName, seen);
+            else
+                _collectRefsInType(decl, exportName, true, seen);
         }
         while (state.pendingMemberCallRefs.length > 0) {
             const { objectName, propertyName, exportName, seen } = state.pendingMemberCallRefs.pop();
@@ -780,7 +845,7 @@ function walkAST(program, sourceText, filePath, hasModuleSyntax, ctx) {
             if (fn.type !== 'ArrowFunctionExpression' && fn.type !== 'FunctionExpression')
                 continue;
             seen.add(key);
-            _collectRefsInType(fn, exportName, true, seen);
+            _collectRefsInCallResult(fn, exportName, seen);
         }
     }
     for (let i = 0; i < state.memberRefsInFile.length; i += 2) {

package/dist/util/cli-arguments.d.ts

@@ -1,5 +1,6 @@
 export declare const helpText = "\u2702\uFE0F  Find unused dependencies, exports and files in your JavaScript and TypeScript projects\n\nUsage: knip [options]\n\nOptions:\n  -h, --help                   Print this help text\n  -V, --version                Print version\n  -n, --no-progress            Don't show dynamic progress updates (automatically enabled in CI environments)\n  -c, --config [file]          Configuration file path\n                               (default: [.]knip.json[c], knip.(js|ts), knip.config.(js|ts) or package.json#knip)\n      --use-tsconfig-files     Use tsconfig.json to define project files (override `project` patterns)\n  -t, --tsConfig [file]        TypeScript configuration path (default: tsconfig.json)\n\nMode\n      --cache                  Enable caching\n      --cache-location         Change cache location (default: node_modules/.cache/knip)\n      --include-entry-exports  Include entry files when reporting unused exports\n      --no-gitignore           Don't respect .gitignore\n  -p, --production             Analyze only production source files (e.g. no test files, devDependencies)\n  -s, --strict                 Consider only direct dependencies of workspace (not devDependencies, not other workspaces)\n  -w, --watch                  Watch mode\n\nScope\n  -W, --workspace [filter]     Filter workspaces by name, directory, or glob (can be repeated)\n  -D, --directory [dir]        Run process from a different directory (default: cwd)\n      --include                Include provided issue type(s), can be comma-separated or repeated (1)\n      --exclude                Exclude provided issue type(s) from report, can be comma-separated or repeated (1)\n      --dependencies           Shortcut for --include dependencies,unlisted,binaries,unresolved,catalog,catalogReferences\n      --exports                Shortcut for --include exports,nsExports,types,nsTypes,enumMembers,namespaceMembers,duplicates\n      --files                  Shortcut for --include files\n      --cycles                 Shortcut for --include cycles (circular dependencies)\n      --tags                   Include or exclude tagged exports\n\nFix\n  -f, --fix                    Fix issues (modifies files in your repo)\n      --fix-type               Fix only issues of type, can be comma-separated or repeated (2)\n      --allow-remove-files     Allow Knip to remove files (with --fix)\n  -F, --format                 Format modified files after --fix using the local formatter\n\nOutput\n      --preprocessor           Preprocess the results before providing it to the reporter(s), can be repeated\n      --preprocessor-options   Pass extra options to the preprocessor (as JSON string, see --reporter-options example)\n      --reporter               Select reporter (default: symbols), can be repeated (3)\n      --reporter-options       Pass extra options to the reporter (as JSON string, see example)\n      --no-config-hints        Suppress configuration hints\n      --no-tag-hints           Suppress tag hints\n      --treat-config-hints-as-errors   Exit with non-zero code (1) if there are any configuration hints\n      --treat-tag-hints-as-errors      Exit with non-zero code (1) if there are any tag hints\n      --max-issues             Maximum number of total issues before non-zero exit code (default: 0)\n      --max-show-issues        Maximum number of issues to display per type\n      --no-exit-code           Always exit with code zero (0)\n\nTroubleshooting\n  -d, --debug                  Show debug output\n      --memory                 Measure memory usage and display data table\n      --memory-realtime        Log memory usage in realtime\n      --performance            Measure count and running time of key functions and display stats table\n      --performance-fn [name]  Measure only function [name]\n  -u, --duration               Print total running time (zero overhead, no instrumentation)\n      --trace                  Show trace output\n      --trace-dependency [name]  Show files that import the named dependency\n      --trace-export [name]    Show trace output for named export(s)\n      --trace-file [file]      Show trace output for exports in file\n\n(1) Issue types: files, dependencies, unlisted, unresolved, exports, nsExports, types, nsTypes, enumMembers, namespaceMembers, duplicates, catalog, catalogReferences, cycles\n(2) Fixable issue types: dependencies, exports, types, files, catalog\n(3) Built-in reporters: symbols (default), compact, codeowners, cycles, json, codeclimate, markdown, disclosure, github-actions, sarif\n\nExamples:\n\n$ knip\n$ knip --production\n$ knip --workspace packages/client --include files,dependencies\n$ knip --workspace @myorg/* --workspace '!@myorg/legacy'\n$ knip --workspace './apps/*' --workspace '@shared/utils'\n$ knip -c ./config/knip.json --reporter compact\n$ knip --reporter codeowners --reporter-options '{\"path\":\".github/CODEOWNERS\"}'\n$ knip --tags=-lintignore\n\nWebsite: https://knip.dev";
 export type ParsedCLIArgs = ReturnType<typeof parseCLIArgs>;
+export declare const parseNumericOption: (value: string | undefined, option: string) => number | undefined;
 export default function parseCLIArgs(): {
     cache?: boolean | undefined;
     'cache-location'?: string | undefined;

package/dist/util/cli-arguments.js

@@ -1,4 +1,5 @@
 import { parseArgs } from 'node:util';
+import { ConfigurationError } from './errors.js';
 export const helpText = `✂️  Find unused dependencies, exports and files in your JavaScript and TypeScript projects
 
 Usage: knip [options]
@@ -79,6 +80,14 @@ $ knip --reporter codeowners --reporter-options '{"path":".github/CODEOWNERS"}'
 $ knip --tags=-lintignore
 
 Website: https://knip.dev`;
+export const parseNumericOption = (value, option) => {
+    if (value === undefined)
+        return undefined;
+    if (!/^\d+$/.test(value)) {
+        throw new ConfigurationError(`Option --${option} expects a non-negative integer, got: ${value}`);
+    }
+    return Number(value);
+};
 export default function parseCLIArgs() {
     return parseArgs({
         options: {

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

@@ -1,5 +1,5 @@
 import type { Options } from '../types/options.ts';
-import type { ParsedCLIArgs } from './cli-arguments.ts';
+import { type ParsedCLIArgs } from './cli-arguments.ts';
 interface CreateOptions extends Partial<Options> {
     args?: ParsedCLIArgs;
 }
@@ -43,6 +43,7 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
     isTreatTagHintsAsErrors: boolean;
     isUseTscFiles: boolean | undefined;
     isWatch: boolean;
+    maxIssues: number;
     maxShowIssues: number | undefined;
     parsedConfig: {
         angular?: string | boolean | string[] | {

package/dist/util/create-options.js

@@ -2,6 +2,7 @@ import { partitionCompilers } from '../compilers/index.js';
 import { ISSUE_TYPES, KNIP_CONFIG_LOCATIONS } from '../constants.js';
 import { knipConfigurationSchema } from '../schema/configuration.js';
 import { getCatalogContainer } from './catalog.js';
+import { parseNumericOption } from './cli-arguments.js';
 import { ConfigurationError } from './errors.js';
 import { findFile, loadJSON } from './fs.js';
 import { getIncludedIssueTypes, shorthandCycles, shorthandDeps, shorthandExports, shorthandFiles, } from './get-included-issue-types.js';
@@ -150,7 +151,8 @@ export const createOptions = async (options) => {
         isTreatTagHintsAsErrors: args['treat-tag-hints-as-errors'] ?? parsedConfig.treatTagHintsAsErrors ?? false,
         isUseTscFiles: options.isUseTscFiles ?? args['use-tsconfig-files'] ?? (options.isSession && !configFilePath),
         isWatch: args.watch ?? options.isWatch ?? false,
-        maxShowIssues: args['max-show-issues'] ? Number(args['max-show-issues']) : undefined,
+        maxIssues: parseNumericOption(args['max-issues'], 'max-issues') ?? 0,
+        maxShowIssues: parseNumericOption(args['max-show-issues'], 'max-show-issues'),
         parsedConfig,
         rules,
         tags,

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.33.0";
+export declare const version = "6.34.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.33.0';
+export const version = '6.34.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.33.0",
+  "version": "6.34.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",
@@ -96,14 +96,14 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@jest/types": "^30.4.1",
+    "@jest/types": "^30.5.0",
     "@types/bun": "^1.4.0",
     "@types/picomatch": "^4.0.3",
-    "@types/webpack": "^5.28.5",
     "codeclimate-types": "^0.3.1",
     "prettier": "^3.9.6",
     "tsx": "^4.23.12",
-    "typescript": "7.0.2"
+    "typescript": "7.0.2",
+    "webpack": "^5.110.1"
   },
   "engines": {
     "node": "^20.19.0 || >=22.12.0"