knip 6.24.0 → 6.25.0

package/dist/graph-explorer/utils.d.ts

@@ -1,5 +1,14 @@
-import type { Import, ImportMaps, ModuleGraph } from '../types/module-graph.ts';
+import type { FileNode, Import, ImportMaps, ModuleGraph } from '../types/module-graph.ts';
+export declare const getIgnoredCycleImportFlags: (includeDynamicImports: boolean) => number;
 export declare const getExportedIdentifiers: (graph: ModuleGraph, filePath: string, visited?: Set<string>) => Map<string, boolean>;
+export declare const getRuntimeSuccessors: (node: FileNode, ignoredFlags?: number) => Set<string>;
+export declare const getRuntimeImport: (node: FileNode, filePath: string, ignoredFlags?: number) => {
+    kind: string;
+    specifier: string;
+    pos: number;
+    line: number;
+    col: number;
+} | undefined;
 export declare const hasStrictlyEnumReferences: (importsForExport: ImportMaps | undefined, identifier: string) => boolean;
 export declare const getIssueType: (hasOnlyNsReference: boolean, isType: boolean) => "exports" | "nsExports" | "nsTypes" | "types";
 export declare const findImportRef: (graph: ModuleGraph, importingFile: string, importedFile: string, identifier: string) => Import | undefined;

package/dist/graph-explorer/utils.js

@@ -1,5 +1,8 @@
+import { IMPORT_FLAGS, IMPORT_STAR, OPAQUE, SIDE_EFFECTS } from '../constants.js';
 import { getCachedExportedIdentifiers, setCachedExportedIdentifiers } from './cache.js';
 import { forEachAliasReExport, forEachNamespaceReExport, forEachPassThroughReExport, getStarReExportSources, } from './visitors.js';
+const IGNORED_CYCLE_IMPORT_FLAGS = IMPORT_FLAGS.ENTRY | IMPORT_FLAGS.DYNAMIC;
+export const getIgnoredCycleImportFlags = (includeDynamicImports) => includeDynamicImports ? IMPORT_FLAGS.ENTRY : IGNORED_CYCLE_IMPORT_FLAGS;
 export const getExportedIdentifiers = (graph, filePath, visited = new Set()) => {
     if (visited.has(filePath))
         return new Map();
@@ -49,6 +52,56 @@ export const getExportedIdentifiers = (graph, filePath, visited = new Set()) =>
     setCachedExportedIdentifiers(graph, filePath, identifiers);
     return identifiers;
 };
+export const getRuntimeSuccessors = (node, ignoredFlags = IGNORED_CYCLE_IMPORT_FLAGS) => {
+    const successors = new Set();
+    for (const _import of node.imports.imports) {
+        if (_import.filePath &&
+            !_import.isTypeOnly &&
+            !(_import.modifiers & ignoredFlags) &&
+            node.imports.internal.has(_import.filePath)) {
+            successors.add(_import.filePath);
+        }
+    }
+    return successors;
+};
+const getImportKind = (importMaps, identifier, modifiers) => {
+    if (modifiers & IMPORT_FLAGS.DYNAMIC)
+        return 'dynamicImport';
+    if (identifier === IMPORT_STAR && importMaps.reExport.has(IMPORT_STAR))
+        return 'reExportStar';
+    if (identifier && importMaps.reExportNs.has(identifier))
+        return 'reExportNS';
+    if (identifier && importMaps.reExportAs.has(identifier))
+        return 'reExportAs';
+    if (identifier && importMaps.reExport.has(identifier))
+        return 'reExport';
+    if (identifier === IMPORT_STAR && importMaps.importNs.size > 0)
+        return 'importNS';
+    if (identifier && importMaps.importAs.has(identifier))
+        return 'importAs';
+    if (identifier === OPAQUE)
+        return 'dynamicImport';
+    if (identifier === SIDE_EFFECTS)
+        return 'sideEffectImport';
+    return 'import';
+};
+export const getRuntimeImport = (node, filePath, ignoredFlags = IGNORED_CYCLE_IMPORT_FLAGS) => {
+    const importMaps = node.imports.internal.get(filePath);
+    if (!importMaps)
+        return;
+    let result;
+    for (const _import of node.imports.imports) {
+        if (_import.filePath !== filePath || _import.isTypeOnly || _import.modifiers & ignoredFlags)
+            continue;
+        if (!result || _import.line < result.line || (_import.line === result.line && _import.col < result.col)) {
+            result = _import;
+        }
+    }
+    if (!result)
+        return;
+    const { specifier, pos, line, col, identifier, modifiers } = result;
+    return { kind: getImportKind(importMaps, identifier, modifiers), specifier, pos, line, col };
+};
 export const hasStrictlyEnumReferences = (importsForExport, identifier) => {
     if (!importsForExport || !importsForExport.refs.has(identifier))
         return false;

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

package/dist/plugins/storybook/index.js

@@ -1,3 +1,4 @@
+import MDX from '../../compilers/mdx.js';
 import { toConfig, toDeferResolve, toDependency, toEntry } from '../../util/input.js';
 import { join, relative } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
@@ -54,6 +55,11 @@ const resolveConfig = async (localConfig, options) => {
         ...configs,
     ];
 };
+const registerCompilers = ({ registerCompiler, hasDependency }) => {
+    if (hasDependency('@storybook/addon-docs') || hasDependency('@storybook/addon-essentials')) {
+        registerCompiler({ extension: '.mdx', compiler: MDX.compiler });
+    }
+};
 const plugin = {
     title,
     enablers,
@@ -62,5 +68,6 @@ const plugin = {
     entry,
     project,
     resolveConfig,
+    registerCompilers,
 };
 export default plugin;