knip 6.14.1 → 6.14.2

package/README.md

@@ -63,7 +63,7 @@ following projects:
 [14]: https://knip.dev/sponsors
 [15]: https://knip.dev/#created-by-awesome-contributors
 [16]: https://www.youtube.com/watch?v=PE7h7KvQoUI&t=9s
-[17]: ./license
+[17]: ./LICENSE
 [18]: https://github.com/npm/package-json
 [19]: https://github.com/npm/package-json/blob/main/LICENSE
 [20]: https://github.com/pnpm/pnpm/tree/main/deps/graph-sequencer

package/dist/DependencyDeputy.js

@@ -179,8 +179,6 @@ export class DependencyDeputy {
     maybeAddReferencedBinary(workspace, binaryName) {
         if (!this.isReportDependencies)
             return new Set();
-        if (IGNORED_GLOBAL_BINARIES.has(binaryName))
-            return new Set();
         this.addReferencedBinary(workspace.name, binaryName);
         const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
         for (const name of workspaceNames) {
@@ -194,6 +192,8 @@ export class DependencyDeputy {
                 }
             }
         }
+        if (IGNORED_GLOBAL_BINARIES.has(binaryName))
+            return new Set();
         return;
     }
     isInDependencies(workspaceName, packageName, isDevOnly) {

package/dist/binaries/resolvers/bun.js

@@ -1,5 +1,5 @@
 import parseArgs from 'minimist';
-import { toEntry } from '../../util/input.js';
+import { toBinary, toEntry } from '../../util/input.js';
 import { isAbsolute, join } from '../../util/path.js';
 import { _resolveSync } from '../../util/resolve.js';
 import { resolveX } from './bunx.js';
@@ -51,27 +51,28 @@ const commands = new Set([
     'x',
 ]);
 export const resolve = (_binary, args, options) => {
+    const binary = toBinary(_binary);
     const parsed = parseArgs(args, { string: ['cwd'] });
     const [command, script] = parsed._;
     if (command === 'x') {
         const argsForX = args.filter(arg => arg !== 'x');
-        return resolveX(argsForX, options);
+        return [binary, ...resolveX(argsForX, options)];
     }
     const { manifest, cwd, fromArgs } = options;
     if (command === 'run' && manifest.scriptNames.has(script))
-        return [];
+        return [binary];
     if (manifest.scriptNames.has(command))
-        return [];
+        return [binary];
     if (command !== 'run' && commands.has(command))
-        return [];
+        return [binary];
     const filePath = command === 'run' ? script : command;
     if (!filePath)
-        return [];
+        return [binary];
     const _cwd = parsed.cwd ? join(cwd, parsed.cwd) : cwd;
     const resolved = _resolveSync(isAbsolute(filePath) ? filePath : join(_cwd, filePath), _cwd);
     if (resolved)
-        return [toEntry(resolved)];
+        return [binary, toEntry(resolved)];
     const dir = parsed.cwd ? join(cwd, parsed.cwd) : undefined;
     const opts = dir ? { cwd: dir } : {};
-    return command === 'run' ? [] : fromArgs(args, opts);
+    return command === 'run' ? [binary] : [binary, ...fromArgs(args, opts)];
 };

package/dist/plugins/astro/index.js

@@ -15,6 +15,7 @@ const production = [
     '!src/pages/**/_*/**',
     'src/content/**/*.mdx',
     'src/middleware.{js,ts}',
+    'src/middleware/index.{js,ts}',
     'src/actions/index.{js,ts}',
 ];
 const resolveFromAST = (program, options) => {

package/dist/plugins/graphql-codegen/index.js

@@ -6,6 +6,9 @@ import { isConfigurationOutput, isGraphqlConfigTypes, isGraphqlProjectsConfigTyp
 const title = 'GraphQL Codegen';
 const enablers = [/^@graphql-codegen\//, 'graphql-config'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const args = {
+    config: true,
+};
 const packageJsonPath = manifest => get(manifest, 'codegen') ?? get(manifest, 'graphql');
 const config = [
     'package.json',
@@ -59,6 +62,7 @@ const resolveConfig = config => {
 };
 const plugin = {
     title,
+    args,
     enablers,
     isEnabled,
     packageJsonPath,

package/dist/plugins/serverless-framework/index.js

@@ -1,17 +1,22 @@
-import { toProductionEntry } from '../../util/input.js';
+import { toDependency, toProductionEntry } from '../../util/input.js';
+import { isInternal, join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Serverless Framework';
 const enablers = ['serverless'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['serverless.{yml,yaml}'];
+const config = ['serverless.{js,cjs,mjs,ts,cts,mts,yml,yaml}'];
 const handlerToEntry = (handler) => {
     const dot = handler.lastIndexOf('.');
     return toProductionEntry(`${handler.slice(0, dot)}.{js,ts}`);
 };
-const resolveConfig = async (config) => {
-    if (!config.functions)
-        return [];
-    return Object.values(config.functions).flatMap(fn => (fn.handler ? [handlerToEntry(fn.handler)] : []));
+const pluginToInput = (plugin, dir) => isInternal(plugin) ? toProductionEntry(join(dir, plugin)) : toDependency(plugin);
+const resolveConfig = async (config, options) => {
+    const functions = config.functions
+        ? Object.values(config.functions).flatMap(fn => (fn.handler ? [handlerToEntry(fn.handler)] : []))
+        : [];
+    const plugins = config.plugins?.filter((plugin) => typeof plugin === 'string') ?? [];
+    const esbuild = config.custom?.esbuild || config.build?.esbuild ? [toDependency('esbuild', { optional: true })] : [];
+    return [...functions, ...plugins.map(plugin => pluginToInput(plugin, options.configFileDir)), ...esbuild];
 };
 const plugin = {
     title,

package/dist/plugins/serverless-framework/types.d.ts

@@ -1,5 +1,12 @@
 export type PluginConfig = {
+    build?: {
+        esbuild?: unknown;
+    };
+    custom?: {
+        esbuild?: unknown;
+    };
     functions?: Record<string, ServerlessFunction>;
+    plugins?: unknown[];
 };
 type ServerlessFunction = {
     handler?: string;

package/dist/plugins/typescript/index.js

@@ -32,7 +32,7 @@ const resolveConfig = async (localConfig, options) => {
     return compact([
         ...extend,
         ...references,
-        ...types.map(id => toDeferResolve(id, { isTypeOnly: true })),
+        ...types.map(id => toDeferResolve(id, { isTypeOnly: true, dir: options.cwd })),
         ...[...plugins, ...importHelpers].map(id => toDeferResolve(id)),
         ...jsx,
         ...aliases,

package/dist/plugins/vite/helpers.d.ts

@@ -1,4 +1,4 @@
 import type { Program } from 'oxc-parser';
 import { type Input } from '../../util/input.ts';
-export declare const getReactBabelInputs: (program: Program) => string[];
+export declare const getBabelInputs: (program: Program) => Input[];
 export declare const getIndexHtmlEntries: (rootDir: string) => Promise<Input[]>;

package/dist/plugins/vite/helpers.js

@@ -1,42 +1,32 @@
 import { Visitor } from 'oxc-parser';
-import { findProperty, getDefaultImportName, getImportMap, getStringValues, resolveObjectArg, } from '../../typescript/ast-helpers.js';
+import { findProperty, getImportMap, getStringValues } from '../../typescript/ast-helpers.js';
 import { isFile, loadFile } from '../../util/fs.js';
 import { toProductionEntry } from '../../util/input.js';
 import { join } from '../../util/path.js';
-export const getReactBabelInputs = (program) => {
-    const inputs = [];
-    const importMap = getImportMap(program);
-    const reactPluginNames = new Set();
-    for (const [importName, importPath] of importMap) {
-        if (importPath.includes('@vitejs/plugin-react'))
-            reactPluginNames.add(importName);
-    }
-    if (reactPluginNames.size === 0) {
-        const defaultImportName = getDefaultImportName(importMap, '@vitejs/plugin-react');
-        if (defaultImportName)
-            reactPluginNames.add(defaultImportName);
-        else
-            reactPluginNames.add('react');
+import { getDependenciesFromConfig } from '../babel/index.js';
+const babelPluginSources = ['@rolldown/plugin-babel', '@vitejs/plugin-react', 'vite-plugin-babel'];
+const isBabelWrappingPlugin = (path) => babelPluginSources.some(source => path === source || path.startsWith(`${source}/`));
+export const getBabelInputs = (program) => {
+    const pluginNames = new Set();
+    for (const [name, path] of getImportMap(program)) {
+        if (isBabelWrappingPlugin(path))
+            pluginNames.add(name);
     }
+    if (pluginNames.size === 0)
+        return [];
+    const inputs = [];
     const visitor = new Visitor({
         CallExpression(node) {
-            if (node.callee?.type !== 'Identifier' || node.callee.name !== 'defineConfig')
-                return;
-            const config = resolveObjectArg(node.arguments?.[0]);
-            const plugins = findProperty(config, 'plugins');
-            if (plugins?.type !== 'ArrayExpression')
+            if (node.callee?.type !== 'Identifier' || !pluginNames.has(node.callee.name))
                 return;
-            for (const el of plugins.elements ?? []) {
-                if (el?.type !== 'CallExpression' || el.callee?.type !== 'Identifier')
-                    continue;
-                if (!reactPluginNames.has(el.callee.name))
-                    continue;
-                const babel = findProperty(el.arguments?.[0], 'babel');
-                for (const key of ['plugins', 'presets']) {
-                    for (const v of getStringValues(findProperty(babel, key)))
-                        inputs.push(v);
-                }
+            const options = node.arguments?.[0];
+            const plugins = [];
+            const presets = [];
+            for (const config of [options, findProperty(options, 'babel'), findProperty(options, 'babelConfig')]) {
+                plugins.push(...getStringValues(findProperty(config, 'plugins')));
+                presets.push(...getStringValues(findProperty(config, 'presets')));
             }
+            inputs.push(...getDependenciesFromConfig({ plugins, presets }));
         },
     });
     visitor.visit(program);

package/dist/plugins/vite/index.js

@@ -1,16 +1,12 @@
-import { toDependency } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
 import { resolveConfig } from '../vitest/index.js';
-import { getIndexHtmlEntries, getReactBabelInputs } from './helpers.js';
+import { getBabelInputs, getIndexHtmlEntries } from './helpers.js';
 import { createImportMetaGlobVisitor } from './visitors/importMetaGlob.js';
 const title = 'Vite';
 const enablers = ['vite', 'vitest'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 export const config = ['vite.config.{js,mjs,ts,cjs,mts,cts}'];
-const resolveFromAST = program => {
-    const inputs = getReactBabelInputs(program);
-    return inputs.map(id => toDependency(id));
-};
+const resolveFromAST = program => getBabelInputs(program);
 const registerVisitors = ({ ctx, registerVisitor }) => {
     registerVisitor(createImportMetaGlobVisitor(ctx));
 };

package/dist/util/create-input-handler.js

@@ -18,7 +18,7 @@ const addExternalRef = (map, containingFilePath, ref) => {
 };
 export const createInputHandler = (deputy, chief, isGitIgnored, addIssue, externalRefs, options) => (input, workspace) => {
     const { specifier, containingFilePath } = input;
-    if (!containingFilePath || IGNORED_RUNTIME_DEPENDENCIES.has(specifier))
+    if (!containingFilePath)
         return;
     if (isBinary(input)) {
         const binaryName = fromBinary(input);
@@ -44,6 +44,8 @@ export const createInputHandler = (deputy, chief, isGitIgnored, addIssue, extern
         });
         return;
     }
+    if (IGNORED_RUNTIME_DEPENDENCIES.has(specifier))
+        return;
     const packageName = getPackageNameFromSpecifier(specifier);
     if (packageName &&
         (isDependency(input) ||

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.14.1";
+export declare const version = "6.14.2";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.14.1';
+export const version = '6.14.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.14.1",
+  "version": "6.14.2",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",