knip 6.12.0 → 6.12.1

package/dist/DependencyDeputy.js

@@ -139,9 +139,10 @@ export class DependencyDeputy {
         if (packageName === workspace.pkgName)
             return true;
         const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
-        const closestWorkspaceName = workspaceNames.find(name => this.isInDependencies(name, packageName, isDevOnly));
+        const isDevOrTypeOnly = isDevOnly || isTypeOnly;
+        const closestWorkspaceName = workspaceNames.find(name => this.isInDependencies(name, packageName, isDevOrTypeOnly));
         const typesPackageName = !isDefinitelyTyped(packageName) && getDefinitelyTypedFor(packageName);
-        const closestWorkspaceNameForTypes = typesPackageName && workspaceNames.find(name => this.isInDependencies(name, typesPackageName, isDevOnly));
+        const closestWorkspaceNameForTypes = typesPackageName && workspaceNames.find(name => this.isInDependencies(name, typesPackageName, isDevOrTypeOnly));
         if (closestWorkspaceNameForTypes && !this.hasTypesIncluded.get(closestWorkspaceNameForTypes)?.has(packageName))
             this.addReferencedDependency(closestWorkspaceNameForTypes, typesPackageName);
         if (closestWorkspaceName) {

package/dist/plugins/vercel/index.js

@@ -1,15 +1,12 @@
-import { isFile } from '../../util/fs.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'Vercel';
-const enablers = 'This plugin is enabled when a Vercel project configuration file is found in the root folder.';
-const entry = ['vercel.{json,js,mjs,cjs,ts,mts}'];
-const configFiles = ['vercel.json', 'vercel.js', 'vercel.mjs', 'vercel.cjs', 'vercel.ts', 'vercel.mts'];
-const isEnabled = ({ cwd }) => configFiles.some(file => isFile(cwd, file));
-const isRootOnly = true;
+const enablers = ['@vercel/config'];
+const entry = ['vercel.{js,mjs,cjs,ts,mts}'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const plugin = {
     title,
     enablers,
     isEnabled,
     entry,
-    isRootOnly,
 };
 export default plugin;

package/dist/typescript/visitors/exports.js

@@ -3,6 +3,11 @@ import { addNsValue, addValue } from '../../util/module-graph.js';
 import { extractEnumMembers, extractNamespaceMembers, getLineAndCol, getStringValue, isStringLiteral, } from './helpers.js';
 import { EMPTY_TAGS } from './jsdoc.js';
 const getName = (n) => (n?.type === 'Identifier' ? n.name : undefined);
+const hasExplicitFunctionReturnType = (node) => !!node &&
+    (node.type === 'ArrowFunctionExpression' ||
+        node.type === 'FunctionExpression' ||
+        node.type === 'FunctionDeclaration') &&
+    Boolean(node.returnType);
 export function handleExportNamed(node, s) {
     if (s.skipExports || s.isInNamespace(node))
         return;
@@ -34,18 +39,24 @@ export function handleExportNamed(node, s) {
                             const name = p.argument.name;
                             const fix = s.options.isFixExports ? [p.start, p.end, FIX_FLAGS.OBJECT_BINDING] : undefined;
                             s.addExport(name, SYMBOL_TYPE.UNKNOWN, p.argument.start, [], fix, false, s.getJSDocTags(exportStart));
+                            if (declarator.init)
+                                s.collectRefsInType(declarator.init, name, false);
                             s.destructuredExports.add(name);
                         }
                         else if (p.value?.type === 'Identifier') {
                             const name = p.value.name;
                             const fix = s.options.isFixExports ? [p.start, p.end, FIX_FLAGS.OBJECT_BINDING] : undefined;
                             s.addExport(name, SYMBOL_TYPE.UNKNOWN, p.value.start, [], fix, false, s.getJSDocTags(exportStart));
+                            if (declarator.init)
+                                s.collectRefsInType(declarator.init, name, false);
                             s.destructuredExports.add(name);
                         }
                         else if (p.value?.type === 'AssignmentPattern' && p.value.left?.type === 'Identifier') {
                             const name = p.value.left.name;
                             const fix = s.options.isFixExports ? [p.start, p.end, FIX_FLAGS.OBJECT_BINDING] : undefined;
                             s.addExport(name, SYMBOL_TYPE.UNKNOWN, p.value.left.start, [], fix, false, s.getJSDocTags(exportStart));
+                            if (declarator.init)
+                                s.collectRefsInType(declarator.init, name, false);
                             s.destructuredExports.add(name);
                         }
                     }
@@ -55,11 +66,15 @@ export function handleExportNamed(node, s) {
                         if (el?.type === 'Identifier') {
                             const fix = s.options.isFixExports ? [el.start, el.end, FIX_FLAGS.NONE] : undefined;
                             s.addExport(el.name, SYMBOL_TYPE.UNKNOWN, el.start, [], fix, false, s.getJSDocTags(exportStart));
+                            if (declarator.init)
+                                s.collectRefsInType(declarator.init, el.name, false);
                             s.destructuredExports.add(el.name);
                         }
                         else if (el?.type === 'RestElement' && el.argument?.type === 'Identifier') {
                             const fix = s.options.isFixExports ? [el.start, el.end, FIX_FLAGS.NONE] : undefined;
                             s.addExport(el.argument.name, SYMBOL_TYPE.UNKNOWN, el.argument.start, [], fix, false, s.getJSDocTags(exportStart));
+                            if (declarator.init)
+                                s.collectRefsInType(declarator.init, el.argument.name, false);
                             s.destructuredExports.add(el.argument.name);
                         }
                     }
@@ -111,10 +126,11 @@ export function handleExportNamed(node, s) {
                         findSpreads(declarator.init, [name]);
                     }
                     s.addExport(name, SYMBOL_TYPE.UNKNOWN, declarator.id.start, [], fix, isReExport, jsDocTags);
-                    if (declarator.id.typeAnnotation)
+                    if (declarator.id.typeAnnotation) {
                         s.collectRefsInType(declarator.id.typeAnnotation, name, true);
-                    if (declarator.init?.type === 'ArrowFunctionExpression' || declarator.init?.type === 'FunctionExpression') {
-                        s.collectRefsInType(declarator.init, name, true);
+                    }
+                    else if (declarator.init) {
+                        s.collectRefsInType(declarator.init, name, hasExplicitFunctionReturnType(declarator.init));
                     }
                     if (!jsDocTags.has(ALIAS_TAG) && declarator.init?.type === 'Identifier') {
                         const initName = declarator.init.name;
@@ -138,11 +154,12 @@ export function handleExportNamed(node, s) {
         else if ((decl.type === 'FunctionDeclaration' || decl.type === 'TSDeclareFunction') && decl.id) {
             const fix = s.getFix(exportStart, exportStart + 7);
             s.addExport(decl.id.name, SYMBOL_TYPE.FUNCTION, decl.id.start, [], fix, false, s.getJSDocTags(exportStart));
-            s.collectRefsInType(decl, decl.id.name, true);
+            s.collectRefsInType(decl, decl.id.name, hasExplicitFunctionReturnType(decl));
         }
         else if (decl.type === 'ClassDeclaration' && decl.id) {
             const fix = s.getFix(exportStart, exportStart + 7);
             s.addExport(decl.id.name, SYMBOL_TYPE.CLASS, decl.id.start, [], fix, false, s.getJSDocTags(exportStart));
+            s.collectRefsInType(decl, decl.id.name, true);
         }
         else if (decl.type === 'TSTypeAliasDeclaration') {
             const fix = s.getTypeFix(exportStart, exportStart + 7);
@@ -216,12 +233,13 @@ export function handleExportDefault(node, s) {
     if (decl.type === 'FunctionDeclaration') {
         type = SYMBOL_TYPE.FUNCTION;
         pos = decl.id?.start ?? decl.start;
-        s.collectRefsInType(decl, 'default', true);
+        s.collectRefsInType(decl, 'default', hasExplicitFunctionReturnType(decl));
     }
     else if (decl.type === 'ClassDeclaration') {
         type = SYMBOL_TYPE.CLASS;
         pos = decl.id?.start ?? decl.start;
         members = [];
+        s.collectRefsInType(decl, 'default', true);
     }
     else if (decl.type === 'TSInterfaceDeclaration') {
         type = SYMBOL_TYPE.INTERFACE;

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

@@ -1,4 +1,4 @@
-import { Visitor, type Program, type Span } from 'oxc-parser';
+import { Visitor, type Class, type Function as FunctionNode, type Program, type Span, 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';
@@ -60,6 +60,18 @@ export interface WalkState extends WalkContext {
     scopeStarts: number[];
     scopeEnds: number[];
     shadowScopes: Map<string, [number, number][]>;
+    localDeclarations: Map<string, FunctionNode | Class | VariableDeclarator>;
+    pendingCallRefs: Array<{
+        name: string;
+        exportName: string;
+        seen: Set<string>;
+    }>;
+    pendingMemberCallRefs: Array<{
+        objectName: string;
+        propertyName: string;
+        exportName: string;
+        seen: Set<string>;
+    }>;
     addExport: (identifier: string, type: SymbolType, pos: number, members: ExportMember[], fix: Fix, isReExport: boolean, jsDocTags: Set<string>) => void;
     getFix: (start: number, end: number, flags?: number) => Fix;
     getTypeFix: (start: number, end: number) => Fix;

package/dist/typescript/visitors/walk.js

@@ -1,4 +1,4 @@
-import { Visitor } from 'oxc-parser';
+import { Visitor, visitorKeys, } from 'oxc-parser';
 import { FIX_FLAGS, IMPORT_FLAGS, OPAQUE, SYMBOL_TYPE } from '../../constants.js';
 import { addValue } from '../../util/module-graph.js';
 import { isInNodeModules } from '../../util/path.js';
@@ -47,42 +47,79 @@ const _addExport = (identifier, type, pos, members, fix, isReExport, jsDocTags)
         });
     }
 };
-const _collectRefsInType = (node, exportName, signatureOnly) => {
-    if (!node || typeof node !== 'object')
+const _collectRefsInType = (node, exportName, signatureOnly, seen = new Set(), inBody = false) => {
+    if (!node)
         return;
-    if (node.type === 'TSTypeQuery') {
-        const name = node.exprName.type === 'Identifier' ? node.exprName.name : undefined;
-        if (name) {
-            const refs = state.referencedInExport.get(name);
-            if (refs)
-                refs.add(exportName);
-            else
-                state.referencedInExport.set(name, new Set([exportName]));
-        }
+    const type = node.type;
+    if (!type)
         return;
+    switch (type) {
+        case 'TSTypeQuery':
+            if (node.exprName?.type === 'Identifier')
+                _addRefInExport(node.exprName.name, exportName);
+            return;
+        case 'TSTypeReference':
+            if (node.typeName?.type === 'Identifier')
+                _addRefInExport(node.typeName.name, exportName);
+            break;
+        case 'CallExpression': {
+            const callee = node.callee;
+            if (callee?.type === 'Identifier') {
+                state.pendingCallRefs.push({ name: callee.name, exportName, seen });
+            }
+            else if (callee?.type === 'MemberExpression' &&
+                !callee.computed &&
+                callee.object?.type === 'Identifier' &&
+                callee.property?.type === 'Identifier') {
+                state.pendingMemberCallRefs.push({
+                    objectName: callee.object.name,
+                    propertyName: callee.property.name,
+                    exportName,
+                    seen,
+                });
+            }
+            if (!inBody) {
+                const args = node.arguments;
+                if (args) {
+                    for (const arg of args) {
+                        if (arg?.type === 'Identifier')
+                            state.pendingCallRefs.push({ name: arg.name, exportName, seen });
+                    }
+                }
+            }
+            break;
+        }
+        case 'FunctionBody':
+        case 'BlockStatement':
+            if (signatureOnly)
+                return;
+            break;
+        case 'TSAsExpression':
+        case 'TSTypeAssertion':
+        case 'TSSatisfiesExpression':
+            if (inBody) {
+                if (node.expression)
+                    _collectRefsInType(node.expression, exportName, signatureOnly, seen, inBody);
+                return;
+            }
+            break;
     }
-    if (signatureOnly && (node.type === 'FunctionBody' || node.type === 'BlockStatement'))
+    const keys = visitorKeys[type];
+    if (!keys)
         return;
-    if (node.type === 'TSTypeReference' && node.typeName.type === 'Identifier') {
-        const name = node.typeName.name;
-        const refs = state.referencedInExport.get(name);
-        if (refs)
-            refs.add(exportName);
-        else
-            state.referencedInExport.set(name, new Set([exportName]));
-    }
-    for (const key in node) {
-        if (key === 'type' || key === 'parent')
-            continue;
+    const childInBody = inBody || type === 'FunctionBody' || type === 'BlockStatement';
+    for (const key of keys) {
         const val = node[key];
+        if (!val)
+            continue;
         if (Array.isArray(val)) {
             for (const item of val) {
-                if (item && typeof item === 'object' && item.type)
-                    _collectRefsInType(item, exportName, signatureOnly);
+                if (item)
+                    _collectRefsInType(item, exportName, signatureOnly, seen, childInBody);
             }
         }
-        else if (val && typeof val === 'object' && val.type) {
-            _collectRefsInType(val, exportName, signatureOnly);
+        else {
+            _collectRefsInType(val, exportName, signatureOnly, seen, childInBody);
         }
     }
 };
@@ -167,12 +204,15 @@ const coreVisitorObject = {
         state.nsRanges.push([node.start, node.end]);
     },
     ClassDeclaration(node) {
-        if (node.id?.name)
+        if (node.id?.name) {
             state.localDeclarationTypes.set(node.id.name, SYMBOL_TYPE.CLASS);
+            state.localDeclarations.set(node.id.name, node);
+        }
     },
     FunctionDeclaration(node) {
         if (node.id?.name) {
             state.localDeclarationTypes.set(node.id.name, SYMBOL_TYPE.FUNCTION);
+            state.localDeclarations.set(node.id.name, node);
             if (state.scopeDepth > 0)
                 _addShadow(node.id.name);
         }
@@ -201,8 +241,10 @@ const coreVisitorObject = {
         }
         else {
             for (const decl of node.declarations) {
-                if (decl.id.type === 'Identifier')
+                if (decl.id.type === 'Identifier') {
                     state.localDeclarationTypes.set(decl.id.name, SYMBOL_TYPE.VARIABLE);
+                    state.localDeclarations.set(decl.id.name, decl);
+                }
             }
         }
     },
@@ -651,6 +693,9 @@ export function walkAST(program, sourceText, filePath, ctx) {
         scopeStarts: [],
         scopeEnds: [],
         shadowScopes: new Map(),
+        localDeclarations: new Map(),
+        pendingCallRefs: [],
+        pendingMemberCallRefs: [],
         addExport: _addExport,
         getFix: _getFix,
         getTypeFix: _getTypeFix,
@@ -659,6 +704,35 @@ export function walkAST(program, sourceText, filePath, ctx) {
         isInNamespace: _isInNamespace,
     };
     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))
+                continue;
+            const decl = state.localDeclarations.get(name);
+            if (!decl)
+                continue;
+            seen.add(name);
+            _collectRefsInType(decl, exportName, true, seen);
+        }
+        while (state.pendingMemberCallRefs.length > 0) {
+            const { objectName, propertyName, exportName, seen } = state.pendingMemberCallRefs.pop();
+            const key = `${objectName}.${propertyName}`;
+            if (seen.has(key))
+                continue;
+            const decl = state.localDeclarations.get(objectName);
+            if (decl?.type !== 'VariableDeclarator' || decl.init?.type !== 'ObjectExpression')
+                continue;
+            const prop = decl.init.properties.find(p => p.type === 'Property' && p.key?.type === 'Identifier' && p.key.name === propertyName);
+            if (prop?.type !== 'Property')
+                continue;
+            const fn = prop.value;
+            if (fn.type !== 'ArrowFunctionExpression' && fn.type !== 'FunctionExpression')
+                continue;
+            seen.add(key);
+            _collectRefsInType(fn, exportName, true, seen);
+        }
+    }
     for (let i = 0; i < state.memberRefsInFile.length; i += 2) {
         const exp = state.exports.get(state.memberRefsInFile[i]);
         if (exp) {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.12.0";
+export declare const version = "6.12.1";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.12.0';
+export const version = '6.12.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.12.0",
+  "version": "6.12.1",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",
@@ -80,7 +80,7 @@
     "fdir": "^6.5.0",
     "formatly": "^0.3.0",
     "get-tsconfig": "4.14.0",
-    "jiti": "^2.6.0",
+    "jiti": "^2.7.0",
     "minimist": "^1.2.8",
     "oxc-parser": "^0.128.0",
     "oxc-resolver": "^11.19.1",