knip 6.23.0 → 6.25.0

package/dist/plugins/astro/compiler-mdx.js

@@ -1,8 +1,17 @@
 import { fencedCodeBlockMatcher, importMatcher, importsWithinFrontmatter, inlineCodeMatcher, } from '../../compilers/compilers.js';
 const frontmatterImportFields = ['layout'];
 const compiler = (text) => {
-    const imports = text.replace(fencedCodeBlockMatcher, '').replace(inlineCodeMatcher, '').matchAll(importMatcher);
     const frontmatterImports = importsWithinFrontmatter(text, frontmatterImportFields);
-    return [...imports, frontmatterImports].join('\n');
+    if (!text.includes('import'))
+        return frontmatterImports;
+    const imports = [];
+    const source = text.replace(fencedCodeBlockMatcher, '').replace(inlineCodeMatcher, '');
+    let match;
+    importMatcher.lastIndex = 0;
+    while ((match = importMatcher.exec(source)))
+        imports.push(match[0]);
+    if (frontmatterImports)
+        imports.push(frontmatterImports);
+    return imports.join('\n');
 };
 export default compiler;

package/dist/plugins/astro/compiler.js

@@ -1,17 +1,21 @@
 import { frontmatterMatcher, scriptBodies } from '../../compilers/compilers.js';
+import { stylePreprocessorImports } from '../../compilers/style-preprocessors.js';
 const propsDeclMatcher = /(?:^|[\s;])(?:interface|type)\s+Props\b/;
 const compiler = (text, path) => {
-    const scripts = [];
+    let out = '';
     const frontmatter = text.match(frontmatterMatcher);
     if (frontmatter?.[1]) {
         let fm = frontmatter[1];
         if (propsDeclMatcher.test(fm) && text.includes('Astro.props'))
             fm += '\ntype __knip_astro_props = Props;';
-        scripts.push(fm);
+        out = fm;
     }
     const scriptContent = scriptBodies(text, path);
     if (scriptContent)
-        scripts.push(scriptContent);
-    return scripts.join('\n');
+        out = out ? `${out}\n${scriptContent}` : scriptContent;
+    const styleImports = stylePreprocessorImports(text, path);
+    if (styleImports)
+        out = out ? `${out}\n${styleImports}` : styleImports;
+    return out;
 };
 export default compiler;

package/dist/plugins/bun/index.js

@@ -1,11 +1,22 @@
+import { isFile } from '../../util/fs.js';
+import { toDeferResolve, toEntry, toIgnore } from '../../util/input.js';
 import parseArgs from '../../util/parse-args.js';
-import { toDeferResolve, toEntry } from '../../util/input.js';
+import { getScriptCommands } from '../../util/scripts.js';
 const title = 'Bun';
-const enablers = ['bun'];
-const hasBunTest = (scripts) => scripts && Object.values(scripts).some(script => /(?<=^|\s)bun test/.test(script));
-const isEnabled = ({ manifest }) => !!hasBunTest(manifest.scripts);
-const config = ['bunfig.toml'];
+const enablers = 'This plugin is enabled when a `bun.lock` or `bun.lockb` file is found or a `bun test` script is configured.';
 const patterns = ['**/*.{test,spec}.{js,jsx,ts,tsx}', '**/*_{test,spec}.{js,jsx,ts,tsx}'];
+const getBunTest = (script) => {
+    for (const { binary, args } of getScriptCommands(script)) {
+        if (binary !== 'bun')
+            continue;
+        const parsed = parseArgs(args, { string: ['timeout', 'rerun-each', 'preload'] });
+        if (parsed._[0] === 'test')
+            return parsed;
+    }
+};
+const hasBunTest = (scripts) => scripts && Object.values(scripts).some(script => typeof script === 'string' && getBunTest(script));
+const isEnabled = ({ cwd, manifest }) => isFile(cwd, 'bun.lock') || isFile(cwd, 'bun.lockb') || !!hasBunTest(manifest.scripts);
+const config = ['bunfig.toml'];
 const resolveConfig = localConfig => {
     const preload = localConfig.test?.preload ?? [];
     return preload.map(specifier => toDeferResolve(specifier));
@@ -20,17 +31,20 @@ const toPatterns = (arg) => {
 };
 const resolve = options => {
     const scripts = { ...options.rootManifest?.scripts, ...options.manifest.scripts };
+    const inputs = [toIgnore('bun', 'dependencies')];
     for (const script of Object.values(scripts)) {
-        if (/(?<=^|\s)bun test/.test(script)) {
-            const parsed = parseArgs(script.split(' '), { string: ['timeout', 'rerun-each', 'preload'] });
-            const args = parsed._.filter(id => id !== 'bun' && id !== 'test');
-            const inputs = (args.length === 0 ? patterns : args.flatMap(toPatterns)).map(toEntry);
-            for (const specifier of [parsed.preload ?? []].flat())
-                inputs.push(toDeferResolve(specifier));
-            return inputs;
-        }
+        if (typeof script !== 'string')
+            continue;
+        const parsed = getBunTest(script);
+        if (!parsed)
+            continue;
+        const targets = parsed._.slice(1);
+        for (const pattern of targets.length === 0 ? patterns : targets.flatMap(toPatterns))
+            inputs.push(toEntry(pattern));
+        for (const specifier of [parsed.preload ?? []].flat())
+            inputs.push(toDeferResolve(specifier));
     }
-    return [];
+    return inputs;
 };
 const plugin = {
     title,

package/dist/plugins/eve/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/eve/index.js

@@ -0,0 +1,22 @@
+import { hasDependency } from '../../util/plugin.js';
+const title = 'eve';
+const enablers = ['eve'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const extensions = '{js,jsx,ts,tsx,mjs,cjs,mts,cts}';
+const rootAgentFileNames = '{agent,instructions,instrumentation,sandbox}';
+const subagentFileNames = '{agent,instructions,sandbox}';
+const production = [
+    `{,agent/}${rootAgentFileNames}.${extensions}`,
+    `{,agent/}sandbox/sandbox.${extensions}`,
+    `{,agent/}{channels,connections,hooks,skills,tools,schedules}/**/*.${extensions}`,
+    `{,agent/}subagents/**/${subagentFileNames}.${extensions}`,
+    `{,agent/}subagents/**/sandbox/sandbox.${extensions}`,
+    `{,agent/}subagents/**/{connections,hooks,skills,tools}/**/*.${extensions}`,
+];
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    production,
+};
+export default plugin;

package/dist/plugins/execa/visitors/execa.js

@@ -1,4 +1,4 @@
-import { getSafeScriptFromArgs, getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
+import { getSafeScriptFromArgs, getScriptFromArg, getScriptFromTemplate } from '../../../typescript/ast-nodes.js';
 const tags = new Set(['$', '$sync']);
 const methods = new Set(['execa', 'execaSync', 'execaCommand', 'execaCommandSync', 'execaNode', '$sync']);
 export function createExecaVisitor(ctx) {
@@ -10,18 +10,12 @@ export function createExecaVisitor(ctx) {
                 : tag.type === 'CallExpression' && tag.callee.type === 'Identifier'
                     ? tag.callee.name
                     : undefined;
-            if (tagName === 'execaNode') {
-                for (const q of node.quasi.quasis) {
-                    if (q.value.raw)
-                        ctx.addScript(`node ${q.value.raw}`);
-                }
-            }
-            else if (tagName && tags.has(tagName)) {
-                for (const q of node.quasi.quasis) {
-                    if (q.value.raw)
-                        ctx.addScript(q.value.raw);
-                }
-            }
+            const isNode = tagName === 'execaNode';
+            if (!isNode && !(tagName && tags.has(tagName)))
+                return;
+            const script = getScriptFromTemplate(node.quasi);
+            if (script)
+                ctx.addScript(isNode ? `node ${script}` : script);
         },
         CallExpression(node) {
             if (node.callee.type !== 'Identifier' || !methods.has(node.callee.name))
@@ -33,11 +27,9 @@ export function createExecaVisitor(ctx) {
                     ctx.addScript(`node ${script}`);
             }
             else if (fnName.startsWith('execaCommand')) {
-                if (node.arguments[0] && isStringLiteral(node.arguments[0])) {
-                    const val = getStringValue(node.arguments[0]);
-                    if (val)
-                        ctx.addScript(val);
-                }
+                const script = getScriptFromArg(node.arguments[0]);
+                if (script)
+                    ctx.addScript(script);
             }
             else {
                 const script = getSafeScriptFromArgs(node.arguments[0], node.arguments[1]);

package/dist/plugins/fumadocs/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/fumadocs/index.js

@@ -0,0 +1,18 @@
+import MDX from '../../compilers/mdx.js';
+import { hasDependency } from '../../util/plugin.js';
+const title = 'Fumadocs';
+const enablers = ['fumadocs-core', 'fumadocs-mdx', 'fumadocs-ui'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const entry = ['source.config.{js,ts,mjs}', 'content/**/*.mdx'];
+const registerCompilers = ({ registerCompiler, hasDependency }) => {
+    if (hasDependency('fumadocs-mdx'))
+        registerCompiler({ extension: '.mdx', compiler: MDX.compiler });
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    entry,
+    registerCompilers,
+};
+export default plugin;

package/dist/plugins/github-actions/index.js

@@ -18,7 +18,7 @@ export const getActionDependencies = (config, options) => {
     return scripts.map(script => join(configFileDir, script));
 };
 const resolveConfig = async (config, options) => {
-    const { rootCwd, getInputsFromScripts, isProduction } = options;
+    const { rootCwd, getInputsFromScripts, isProduction, getManifest } = options;
     const inputs = new Set();
     const jobs = findByKeyDeep(config, 'steps');
     for (const steps of jobs) {
@@ -30,7 +30,8 @@ const resolveConfig = async (config, options) => {
             const workingDir = step['working-directory'];
             const dir = join(rootCwd, path && workingDir ? relative(workingDir, path) : workingDir ? workingDir : '.');
             if (step.run) {
-                for (const input of getInputsFromScripts([step.run], { knownBinsOnly: true })) {
+                const manifest = getManifest(dir) ?? options.manifest;
+                for (const input of getInputsFromScripts([step.run], { knownBinsOnly: true, manifest })) {
                     if (isDeferResolveEntry(input) && path && !workingDir) {
                         input.specifier = relative(join(dir, path), join(rootCwd, input.specifier));
                     }

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

@@ -1,6 +1,6 @@
-import { toDependency, toEntry } from '../../util/input.js';
+import { toDependency, toEntry, toProductionEntry } from '../../util/input.js';
 import { get } from '../../util/object.js';
-import { isInternal } from '../../util/path.js';
+import { isInternal, join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { isConfigurationOutput, isGraphqlConfigTypes, isGraphqlProjectsConfigTypes } from './types.js';
 const title = 'GraphQL Codegen';
@@ -24,15 +24,17 @@ const getPluginPackageName = (name) => {
         return name;
     return `@graphql-codegen/${name}`;
 };
-const resolveConfig = config => {
+const resolveConfig = (config, options) => {
     const codegenConfigs = isGraphqlProjectsConfigTypes(config)
         ? Object.values(config.projects).flatMap(project => project.extensions?.codegen ?? [])
         : isGraphqlConfigTypes(config)
             ? [config.extensions?.codegen]
             : [config];
-    const generateSet = codegenConfigs
-        .filter((config) => Boolean(config?.generates))
-        .flatMap(config => Object.values(config.generates));
+    const generateConfigs = codegenConfigs.filter((config) => Boolean(config?.generates));
+    const generateSet = generateConfigs.flatMap(config => Object.values(config.generates));
+    const outputs = generateConfigs
+        .flatMap(config => Object.keys(config.generates))
+        .map(output => toProductionEntry(join(options.configFileDir, output.endsWith('/') ? `${output}**` : output)));
     const configurationOutput = generateSet.filter(isConfigurationOutput);
     const presets = configurationOutput
         .map(configOutput => (configOutput.preset ? configOutput.preset : undefined))
@@ -58,7 +60,7 @@ const resolveConfig = config => {
             return [toEntry(plugin)];
         return [toDependency(getPluginPackageName(plugin))];
     });
-    return [...presets, ...flatPlugins, ...nestedPlugins].map(id => (typeof id === 'string' ? toDependency(id) : id));
+    return [...presets, ...flatPlugins, ...nestedPlugins, ...outputs].map(id => typeof id === 'string' ? toDependency(id) : id);
 };
 const plugin = {
     title,

package/dist/plugins/index.d.ts

@@ -29,6 +29,7 @@ export declare const Plugins: {
     drizzle: import("../types/config.ts").Plugin;
     eleventy: import("../types/config.ts").Plugin;
     eslint: import("../types/config.ts").Plugin;
+    eve: import("../types/config.ts").Plugin;
     execa: import("../types/config.ts").Plugin;
     expo: import("../types/config.ts").Plugin;
     'expressive-code': {
@@ -38,6 +39,7 @@ export declare const Plugins: {
         config: string[];
     };
     fast: import("../types/config.ts").Plugin;
+    fumadocs: import("../types/config.ts").Plugin;
     gatsby: import("../types/config.ts").Plugin;
     'github-action': import("../types/config.ts").Plugin;
     'github-actions': import("../types/config.ts").Plugin;

package/dist/plugins/index.js

@@ -28,10 +28,12 @@ import { default as dotenv } from './dotenv/index.js';
 import { default as drizzle } from './drizzle/index.js';
 import { default as eleventy } from './eleventy/index.js';
 import { default as eslint } from './eslint/index.js';
+import { default as eve } from './eve/index.js';
 import { default as execa } from './execa/index.js';
 import { default as expo } from './expo/index.js';
 import { default as expressiveCode } from './expressive-code/index.js';
 import { default as fast } from './fast/index.js';
+import { default as fumadocs } from './fumadocs/index.js';
 import { default as gatsby } from './gatsby/index.js';
 import { default as githubAction } from './github-action/index.js';
 import { default as githubActions } from './github-actions/index.js';
@@ -186,10 +188,12 @@ export const Plugins = {
     drizzle,
     eleventy,
     eslint,
+    eve,
     execa,
     expo,
     'expressive-code': expressiveCode,
     fast,
+    fumadocs,
     gatsby,
     'github-action': githubAction,
     'github-actions': githubActions,

package/dist/plugins/jest/index.js

@@ -3,6 +3,7 @@ import { _glob, _dirGlob } from '../../util/glob.js';
 import { toDeferResolve, toEntry } from '../../util/input.js';
 import { isInternal, join, normalize, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
+import { getDependenciesFromConfig } from '../babel/index.js';
 import { getReportersDependencies, resolveExtensibleConfig } from './helpers.js';
 const title = 'Jest';
 const enablers = ['jest'];
@@ -11,6 +12,7 @@ const config = ['jest.config.{js,ts,mjs,cjs,mts,cts,json}', 'package.json'];
 const mocks = ['**/__mocks__/**/*.[jt]s?(x)'];
 const entry = ['**/__tests__/**/*.?(c|m)[jt]s?(x)', '**/?(*.)+(spec|test).?(c|m)[jt]s?(x)', ...mocks];
 const rootDirRe = /<rootDir>/;
+const isBabelJest = (transformer) => transformer[0] === 'babel-jest';
 const resolveDependencies = async (config, rootDir, options) => {
     const { configFileDir } = options;
     if (config?.preset) {
@@ -46,9 +48,17 @@ const resolveDependencies = async (config, rootDir, options) => {
     const resolvers = config.resolver ? [config.resolver] : [];
     const reporters = getReportersDependencies(config, options);
     const watchPlugins = config.watchPlugins?.map(watchPlugin => (typeof watchPlugin === 'string' ? watchPlugin : watchPlugin[0])) ?? [];
-    const transform = config.transform
-        ? Object.values(config.transform).map(transform => (typeof transform === 'string' ? transform : transform[0]))
-        : [];
+    const transform = [];
+    for (const transformer of config.transform ? Object.values(config.transform) : []) {
+        if (typeof transformer === 'string') {
+            transform.push(transformer);
+        }
+        else {
+            transform.push(transformer[0]);
+            if (isBabelJest(transformer))
+                transform.push(...getDependenciesFromConfig(transformer[1]));
+        }
+    }
     const moduleNameMapper = (config.moduleNameMapper
         ? Object.values(config.moduleNameMapper).map(mapper => (typeof mapper === 'string' ? mapper : mapper[0]))
         : []).filter(value => !/\$[0-9]/.test(value));

package/dist/plugins/next/index.js

@@ -1,3 +1,4 @@
+import { isDirectory } from '../../util/fs.js';
 import { toConfig, toProductionEntry } from '../../util/input.js';
 import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
@@ -5,29 +6,41 @@ import { getPageExtensions } from './resolveFromAST.js';
 const title = 'Next.js';
 const enablers = ['next'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['next.config.{js,ts,cjs,mjs}'];
+const config = ['next.config.{js,ts,cjs,mjs,mts}'];
 const defaultPageExtensions = ['{js,jsx,ts,tsx}'];
 const productionEntryFilePatterns = [
     'app/{,[(]*[)]/}{manifest,robots}.{js,ts}',
     'app/**/sitemap.{js,ts}',
     'app/**/{icon,apple-icon,opengraph-image,twitter-image}.{js,jsx,ts,tsx}',
 ];
-const getEntryFilePatterns = (pageExtensions = defaultPageExtensions) => {
+const rootOrSrc = '{,src/}';
+const getRouterDirPrefix = (cwd, name) => {
+    if (!cwd)
+        return rootOrSrc;
+    if (isDirectory(cwd, name))
+        return '';
+    if (isDirectory(cwd, `src/${name}`))
+        return 'src/';
+    return rootOrSrc;
+};
+const getEntryFilePatterns = (pageExtensions = defaultPageExtensions, cwd) => {
     const ext = pageExtensions.length === 1 ? pageExtensions[0] : `{${pageExtensions.join(',')}}`;
+    const appDirPrefix = getRouterDirPrefix(cwd, 'app');
+    const pagesDirPrefix = getRouterDirPrefix(cwd, 'pages');
     return [
-        ...productionEntryFilePatterns,
-        `{instrumentation,instrumentation-client,middleware,proxy}.${ext}`,
-        `app/global-{error,not-found}.${ext}`,
-        `app/**/{default,error,forbidden,loading,not-found,unauthorized}.${ext}`,
-        `app/**/{layout,page,route,template}.${ext}`,
-        `pages/**/*.${ext}`,
-    ].flatMap(pattern => [pattern, `src/${pattern}`]);
+        ...productionEntryFilePatterns.map(pattern => `${appDirPrefix}${pattern}`),
+        `${rootOrSrc}{instrumentation,instrumentation-client,middleware,proxy}.${ext}`,
+        `${appDirPrefix}app/global-{error,not-found}.${ext}`,
+        `${appDirPrefix}app/**/{default,error,forbidden,loading,not-found,unauthorized}.${ext}`,
+        `${appDirPrefix}app/**/{layout,page,route,template}.${ext}`,
+        `${pagesDirPrefix}pages/**/*.${ext}`,
+    ];
 };
 const production = getEntryFilePatterns();
 const resolveFromAST = (program, { configFileDir }) => {
     const pageExtensions = getPageExtensions(program);
     const extensions = pageExtensions.length > 0 ? pageExtensions : defaultPageExtensions;
-    const patterns = [...getEntryFilePatterns(extensions), 'next-env.d.ts'];
+    const patterns = [...getEntryFilePatterns(extensions, configFileDir), 'next-env.d.ts'];
     return patterns.map(id => toProductionEntry(join(configFileDir, id)));
 };
 const commands = new Set(['dev', 'build', 'start']);

package/dist/plugins/node/index.js

@@ -1,4 +1,5 @@
 import { toEntry, toProductionEntry } from '../../util/input.js';
+import { getScriptCommands } from '../../util/scripts.js';
 const title = 'Node.js';
 const isEnabled = () => true;
 const patterns = [
@@ -7,7 +8,9 @@ const patterns = [
     '**/test.{cjs,mjs,js,cts,mts,ts}',
     '**/test/**/*.{cjs,mjs,js,cts,mts,ts}',
 ];
-const hasNodeTest = (scripts) => scripts && Object.values(scripts).some(script => /(?<=^|\s)(node|nub)\s(.*)--test/.test(script));
+const hasNodeTest = (scripts) => scripts &&
+    Object.values(scripts).some(script => typeof script === 'string' &&
+        getScriptCommands(script).some(({ binary, args }) => (binary === 'node' || binary === 'nub') && args.includes('--test')));
 const entry = ['server.js'];
 const resolve = options => {
     const entries = entry.map(id => toProductionEntry(id));

package/dist/plugins/nuxt/index.js

@@ -82,10 +82,12 @@ const registerCompilers = async ({ cwd, hasDependency, registerCompiler }) => {
                 if (store)
                     store.push(...components);
                 else
-                    componentMap.set(id, [...components]);
+                    componentMap.set(id, components);
             }
         }
         const getSyntheticImports = (identifiers, templateTags) => {
+            if (importMap.size === 0 && (!templateTags || componentMap.size === 0))
+                return [];
             const syntheticImports = [];
             for (const [name, specifier] of importMap) {
                 if (identifiers.has(name))
@@ -113,7 +115,7 @@ const registerCompilers = async ({ cwd, hasDependency, registerCompiler }) => {
                 scripts.push(descriptor.script.content);
             if (descriptor.scriptSetup?.content)
                 scripts.push(descriptor.scriptSetup.content);
-            const identifiers = collectIdentifiers(scripts.join('\n'), path);
+            const identifiers = scripts.length === 0 ? new Set() : collectIdentifiers(scripts.join('\n'), path);
             let templateTags;
             if (descriptor.template?.ast) {
                 const info = collectTemplateInfo(descriptor.template.ast);

package/dist/plugins/pnpm/index.js

@@ -1,12 +1,32 @@
 import { isFile } from '../../util/fs.js';
+import { toDependency, toEntry } from '../../util/input.js';
 const title = 'pnpm';
+const enablers = 'This plugin is enabled when a `pnpm-lock.yaml` or `pnpm-workspace.yaml` file is found in the root directory, or when `pnpm@` is specified in the `packageManager` field of `package.json`.';
 const isEnabled = async ({ cwd, manifest }) => manifest.packageManager?.startsWith('pnpm@') || isFile(cwd, 'pnpm-lock.yaml') || isFile(cwd, 'pnpm-workspace.yaml');
 const isRootOnly = true;
-const config = ['.pnpmfile.cjs'];
+const entry = ['.pnpmfile.{cjs,mjs}'];
+const config = ['package.json', 'pnpm-workspace.yaml'];
+const resolveConfig = config => {
+    const inputs = entry.map(toEntry);
+    const packageExtensions = config?.pnpm?.packageExtensions || config?.packageExtensions;
+    if (packageExtensions) {
+        for (const extension of Object.values(packageExtensions)) {
+            if (extension.peerDependencies) {
+                for (const dep of Object.keys(extension.peerDependencies)) {
+                    inputs.push(toDependency(dep));
+                }
+            }
+        }
+    }
+    return inputs;
+};
 const plugin = {
     title,
+    enablers,
     isEnabled,
     isRootOnly,
+    entry,
     config,
+    resolveConfig,
 };
 export default plugin;

package/dist/plugins/pnpm/types.d.ts

@@ -0,0 +1,6 @@
+import type { Dependencies, PackageJson } from '../../types/package-json.ts';
+export type PnpmConfig = PackageJson & {
+    packageExtensions?: Record<string, {
+        peerDependencies?: Dependencies;
+    }>;
+};

package/dist/plugins/pnpm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/prettier/index.js

@@ -12,9 +12,25 @@ const config = [
 const resolveConfig = config => {
     if (typeof config === 'string')
         return [toDeferResolve(config)];
-    return Array.isArray(config.plugins)
-        ? config.plugins.filter((plugin) => typeof plugin === 'string').map(id => toDependency(id))
-        : [];
+    const result = new Set();
+    const processOptions = (options) => {
+        if (Array.isArray(options.plugins)) {
+            for (const plugin of options.plugins) {
+                if (typeof plugin === 'string') {
+                    result.add(toDependency(plugin));
+                }
+            }
+        }
+    };
+    processOptions(config);
+    if (config.overrides) {
+        for (const override of config.overrides) {
+            if (override.options) {
+                processOptions(override.options);
+            }
+        }
+    }
+    return Array.from(result);
 };
 const args = {
     config: true,

package/dist/plugins/prettier/types.d.ts

@@ -1,4 +1,4 @@
-export type PrettierConfig = {
+export type PrettierOptions = {
     plugins?: (string | {
         parsers?: Record<string, unknown>;
         printers?: Record<string, unknown>;
@@ -6,3 +6,8 @@ export type PrettierConfig = {
         options?: Record<string, unknown>;
     })[];
 };
+export type PrettierConfig = PrettierOptions & {
+    overrides?: {
+        options?: PrettierOptions;
+    }[];
+};

package/dist/plugins/prisma/compiler.js

@@ -1,7 +1,10 @@
 const directiveMatcher = /generator\s+(?!client)\w+\s*\{\s*provider\s*=\s*"([^"]+)"[^}]*\}/g;
 const compiler = (text) => {
+    if (!text.includes('generator'))
+        return '';
     const imports = [];
     let match;
+    directiveMatcher.lastIndex = 0;
     while ((match = directiveMatcher.exec(text))) {
         if (match[1]) {
             imports.push(`import '${match[1]}';`);

package/dist/plugins/rspack/index.js

@@ -1,5 +1,6 @@
 import { hasDependency } from '../../util/plugin.js';
 import { findWebpackDependenciesFromConfig } from '../webpack/index.js';
+import { createRequireContextVisitor } from '../webpack/visitors/requireContext.js';
 const title = 'Rspack';
 const enablers = ['@rspack/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -8,11 +9,15 @@ const resolveConfig = async (localConfig, options) => {
     const inputs = await findWebpackDependenciesFromConfig(localConfig, options);
     return inputs.filter(input => !input.specifier.startsWith('builtin:'));
 };
+const registerVisitors = ({ ctx, registerVisitor }) => {
+    registerVisitor(createRequireContextVisitor(ctx));
+};
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
     resolveConfig,
+    registerVisitors,
 };
 export default plugin;

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

@@ -1,3 +1,4 @@
+import { arrayify } from '../../util/array.js';
 import { toDependency, toProductionEntry } from '../../util/input.js';
 import { isInternal, join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
@@ -10,13 +11,23 @@ const handlerToEntry = (handler) => {
     return toProductionEntry(`${handler.slice(0, dot)}.{js,ts}`);
 };
 const pluginToInput = (plugin, dir) => isInternal(plugin) ? toProductionEntry(join(dir, plugin)) : toDependency(plugin);
+const getInjectEntries = (esbuild, dir) => esbuild && typeof esbuild === 'object' ? arrayify(esbuild.inject).map(id => toProductionEntry(join(dir, id))) : [];
 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 injectEntries = [
+        ...getInjectEntries(config.custom?.esbuild, options.configFileDir),
+        ...getInjectEntries(config.build?.esbuild, options.configFileDir),
+    ];
+    return [
+        ...functions,
+        ...plugins.map(plugin => pluginToInput(plugin, options.configFileDir)),
+        ...esbuild,
+        ...injectEntries,
+    ];
 };
 const plugin = {
     title,

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

@@ -1,13 +1,16 @@
 export type PluginConfig = {
     build?: {
-        esbuild?: unknown;
+        esbuild?: EsbuildConfig;
     };
     custom?: {
-        esbuild?: unknown;
+        esbuild?: EsbuildConfig;
     };
     functions?: Record<string, ServerlessFunction>;
     plugins?: unknown[];
 };
+export type EsbuildConfig = {
+    inject?: string[];
+} | boolean;
 type ServerlessFunction = {
     handler?: string;
 };