knip 6.38.0 → 6.40.0

package/dist/plugins/index.d.ts

@@ -51,6 +51,7 @@ export declare const Plugins: {
     hardhat: import("../types/config.ts").Plugin;
     husky: import("../types/config.ts").Plugin;
     'i18next-parser': import("../types/config.ts").Plugin;
+    jasmine: import("../types/config.ts").Plugin;
     jest: import("../types/config.ts").Plugin;
     karma: import("../types/config.ts").Plugin;
     knex: import("../types/config.ts").Plugin;
@@ -92,6 +93,7 @@ export declare const Plugins: {
     'openapi-ts': import("../types/config.ts").Plugin;
     openclaw: import("../types/config.ts").Plugin;
     orval: import("../types/config.ts").Plugin;
+    osls: import("../types/config.ts").Plugin;
     oxfmt: import("../types/config.ts").Plugin;
     oxlint: import("../types/config.ts").Plugin;
     'panda-css': import("../types/config.ts").Plugin;
@@ -111,6 +113,7 @@ export declare const Plugins: {
     prisma: import("../types/config.ts").Plugin;
     quasar: import("../types/config.ts").Plugin;
     qwik: import("../types/config.ts").Plugin;
+    railway: import("../types/config.ts").Plugin;
     raycast: import("../types/config.ts").Plugin;
     'react-cosmos': import("../types/config.ts").Plugin;
     'react-email': import("../types/config.ts").Plugin;

package/dist/plugins/index.js

@@ -45,6 +45,7 @@ import { default as graphqlCodegen } from './graphql-codegen/index.js';
 import { default as hardhat } from './hardhat/index.js';
 import { default as husky } from './husky/index.js';
 import { default as i18nextParser } from './i18next-parser/index.js';
+import { default as jasmine } from './jasmine/index.js';
 import { default as jest } from './jest/index.js';
 import { default as karma } from './karma/index.js';
 import { default as knex } from './knex/index.js';
@@ -86,6 +87,7 @@ import { default as oclif } from './oclif/index.js';
 import { default as openapiTs } from './openapi-ts/index.js';
 import { default as openclaw } from './openclaw/index.js';
 import { default as orval } from './orval/index.js';
+import { default as osls } from './osls/index.js';
 import { default as oxfmt } from './oxfmt/index.js';
 import { default as oxlint } from './oxlint/index.js';
 import { default as pandaCss } from './panda-css/index.js';
@@ -105,6 +107,7 @@ import { default as prettier } from './prettier/index.js';
 import { default as prisma } from './prisma/index.js';
 import { default as quasar } from './quasar/index.js';
 import { default as qwik } from './qwik/index.js';
+import { default as railway } from './railway/index.js';
 import { default as raycast } from './raycast/index.js';
 import { default as reactCosmos } from './react-cosmos/index.js';
 import { default as reactEmail } from './react-email/index.js';
@@ -233,6 +236,7 @@ export const Plugins = {
     hardhat,
     husky,
     'i18next-parser': i18nextParser,
+    jasmine,
     jest,
     karma,
     knex,
@@ -274,6 +278,7 @@ export const Plugins = {
     'openapi-ts': openapiTs,
     openclaw,
     orval,
+    osls,
     oxfmt,
     oxlint,
     'panda-css': pandaCss,
@@ -293,6 +298,7 @@ export const Plugins = {
     prisma,
     quasar,
     qwik,
+    railway,
     raycast,
     'react-cosmos': reactCosmos,
     'react-email': reactEmail,

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

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

package/dist/plugins/jasmine/index.js

@@ -0,0 +1,55 @@
+import { toDeferResolve, toEntry } from '../../util/input.js';
+import { isAbsolute, join } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+const title = 'Jasmine';
+const enablers = ['jasmine'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['spec/support/jasmine.{json,jsonc,js,cjs,mjs}'];
+const defaultSpecFiles = 'spec/**/*[sS]pec.{js,mjs}';
+const entry = [defaultSpecFiles, 'spec/helpers/**/*.{js,mjs}'];
+const toSpecDirPattern = (specDir, pattern) => {
+    const isNegated = pattern.startsWith('!');
+    const id = isNegated ? pattern.slice(1) : pattern;
+    const resolved = isAbsolute(id) ? id : join(specDir, id);
+    return isNegated ? `!${resolved}` : resolved;
+};
+const resolveConfig = (localConfig, options) => {
+    const specDir = localConfig.spec_dir ?? '';
+    const specFiles = localConfig.spec_files?.map(pattern => toSpecDirPattern(specDir, pattern)) ?? [defaultSpecFiles];
+    const helpers = localConfig.helpers?.map(pattern => toSpecDirPattern(specDir, pattern)) ?? [];
+    const requires = localConfig.requires ?? [];
+    const inputs = [];
+    for (const id of [...specFiles, ...helpers])
+        inputs.push(toEntry(id));
+    for (const id of requires)
+        inputs.push(toDeferResolve(id, { dir: options.cwd }));
+    if (localConfig.loader)
+        inputs.push(toDeferResolve(localConfig.loader, { dir: options.cwd }));
+    return inputs;
+};
+const commands = new Set(['init', 'examples', 'help', 'version']);
+const args = {
+    boolean: ['color', 'fail-fast', 'list-not-applicable', 'no-color'],
+    string: ['config', 'reporter', 'require'],
+    config: ['config'],
+    resolve: ['require', 'reporter'],
+    resolveInputs: (parsed) => {
+        const inputs = [];
+        for (const value of parsed._) {
+            if (commands.has(value) || /^\w+=/.test(value))
+                continue;
+            inputs.push(toEntry(value));
+        }
+        return inputs;
+    },
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    entry,
+    resolveConfig,
+    args,
+};
+export default plugin;

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

@@ -0,0 +1,7 @@
+export type JasmineConfig = {
+    spec_dir?: string;
+    spec_files?: string[];
+    helpers?: string[];
+    requires?: string[];
+    loader?: string;
+};

package/dist/plugins/jasmine/types.js

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

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

@@ -1,4 +1,5 @@
 import type { PluginOptions } from '../../types/config.ts';
 import type { JestInitialOptions } from './types.ts';
 export declare const resolveExtensibleConfig: (configFilePath: string) => Promise<any>;
+export declare const resolveWithPrefix: (prefix: string, id: string, rootDir: string) => string;
 export declare const getReportersDependencies: (config: JestInitialOptions, options: PluginOptions) => string[];

package/dist/plugins/jest/helpers.js

@@ -1,5 +1,6 @@
 import { dirname, isInternal, join, toAbsolute } from '../../util/path.js';
 import { load } from '../../util/plugin.js';
+import { _resolveSync } from '../../util/resolve.js';
 export const resolveExtensibleConfig = async (configFilePath) => {
     let config = await load(configFilePath);
     if (config?.preset) {
@@ -12,6 +13,7 @@ export const resolveExtensibleConfig = async (configFilePath) => {
     }
     return config;
 };
+export const resolveWithPrefix = (prefix, id, rootDir) => _resolveSync(prefix + id, rootDir) ? prefix + id : id;
 const getStringPropOrFallback = (prop, fallback) => {
     return typeof prop === 'string' ? prop : fallback;
 };

package/dist/plugins/jest/index.js

@@ -1,10 +1,10 @@
 import { arrayify } from '../../util/array.js';
 import { _glob, _dirGlob } from '../../util/glob.js';
-import { toConfig, toDeferResolve, toEntry } from '../../util/input.js';
+import { toConfig, toDeferResolve, toDependency, 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';
+import { getReportersDependencies, resolveExtensibleConfig, resolveWithPrefix } from './helpers.js';
 const title = 'Jest';
 const enablers = ['jest'];
 const isEnabled = ({ dependencies, manifest }) => hasDependency(dependencies, enablers) || Boolean(manifest.name?.startsWith('jest-presets'));
@@ -38,16 +38,23 @@ const resolveDependencies = async (config, rootDir, options) => {
                 projects.push(dependency);
         }
     }
-    const runner = config.runner ? [typeof config.runner === 'string' ? config.runner : config.runner[0]] : [];
+    const runner = config.runner
+        ? [resolveWithPrefix('jest-runner-', typeof config.runner === 'string' ? config.runner : config.runner[0], rootDir)]
+        : [];
     const runtime = config.runtime && config.runtime !== 'jest-circus' ? [config.runtime] : [];
-    const environments = config.testEnvironment === 'jsdom'
-        ? ['jest-environment-jsdom']
-        : config.testEnvironment
-            ? [config.testEnvironment]
-            : [];
+    const environments = [];
+    if (config.testEnvironment === 'node') {
+        environments.push(toDependency('jest-environment-node', { optional: true }));
+    }
+    else if (config.testEnvironment) {
+        const environment = config.testEnvironment === 'jsdom'
+            ? 'jest-environment-jsdom'
+            : resolveWithPrefix('jest-environment-', config.testEnvironment, rootDir);
+        environments.push(toDeferResolve(environment));
+    }
     const resolvers = config.resolver ? [config.resolver] : [];
     const reporters = getReportersDependencies(config, options);
-    const watchPlugins = config.watchPlugins?.map(watchPlugin => (typeof watchPlugin === 'string' ? watchPlugin : watchPlugin[0])) ?? [];
+    const watchPlugins = config.watchPlugins?.map(watchPlugin => resolveWithPrefix('jest-watch-', typeof watchPlugin === 'string' ? watchPlugin : watchPlugin[0], rootDir)) ?? [];
     const transform = [];
     for (const transformer of config.transform ? Object.values(config.transform) : []) {
         if (typeof transformer === 'string') {
@@ -69,7 +76,9 @@ const resolveDependencies = async (config, rootDir, options) => {
     const testResultsProcessor = config.testResultsProcessor ? [config.testResultsProcessor] : [];
     const snapshotResolver = config.snapshotResolver ? [config.snapshotResolver] : [];
     const snapshotSerializers = config.snapshotSerializers ?? [];
-    const testSequencer = config.testSequencer ? [config.testSequencer] : [];
+    const testSequencer = config.testSequencer
+        ? [resolveWithPrefix('jest-sequencer-', config.testSequencer, rootDir)]
+        : [];
     const setupFiles = config.setupFiles ?? [];
     const setupFilesAfterEnv = config.setupFilesAfterEnv ?? [];
     const globalSetup = config.globalSetup ? [config.globalSetup] : [];
@@ -99,7 +108,7 @@ const resolveConfig = async (localConfig, options) => {
     const { configFileDir } = options;
     if (typeof localConfig === 'function')
         localConfig = await localConfig();
-    const rootDir = localConfig.rootDir ?? configFileDir;
+    const rootDir = toAbsolute(localConfig.rootDir ?? configFileDir, configFileDir);
     const replaceRootDir = (name) => name.replace(rootDirRe, rootDir);
     const inputs = await resolveDependencies(localConfig, rootDir, options);
     const entries = localConfig.testMatch

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

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

package/dist/plugins/osls/index.js

@@ -0,0 +1,13 @@
+import { hasDependency } from '../../util/plugin.js';
+import { config, resolveConfig } from '../serverless-framework/index.js';
+const title = 'osls';
+const enablers = ['osls'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    resolveConfig,
+};
+export default plugin;

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

@@ -1,3 +1,6 @@
 import type { Plugin } from '../../types/config.ts';
+import { type Input } from '../../util/input.ts';
+import type { OxlintConfig } from './types.ts';
+export declare const resolveExtendedConfig: (config: OxlintConfig, configFilePath: string) => Input[];
 declare const plugin: Plugin;
 export default plugin;

package/dist/plugins/oxlint/index.js

@@ -1,15 +1,11 @@
-import { Visitor } from 'oxc-parser';
-import { findProperty, getPropertyValues } from '../../typescript/ast-helpers.js';
 import { toConfig, toDependency, toEntry } from '../../util/input.js';
 import { dirname, isInternal, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getInputsFromSettings } from '../eslint/helpers.js';
-import { getInputsFromSettingsAST } from '../eslint/resolveFromAST.js';
 const title = 'Oxlint';
 const enablers = ['oxlint', 'vite-plus'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['.oxlintrc.{json,jsonc}', 'oxlint.config.{ts,mts}', 'vite.config.{js,mjs,ts,cjs,mts,cts}'];
-const isViteConfig = (configFileName) => configFileName.startsWith('vite.config.');
+const config = ['.oxlintrc.{json,jsonc}', 'oxlint.config.{ts,mts}'];
 const args = {
     config: true,
 };
@@ -25,8 +21,7 @@ const resolveJsPlugins = (jsPlugins, configFilePath) => {
     }
     return inputs;
 };
-const isLoadConfig = ({ configFileName }) => !isViteConfig(configFileName);
-const resolveExtendedConfig = (config, configFilePath) => {
+export const resolveExtendedConfig = (config, configFilePath) => {
     const inputs = [];
     for (const entry of config.extends ?? []) {
         if (typeof entry === 'string') {
@@ -43,43 +38,21 @@ const resolveExtendedConfig = (config, configFilePath) => {
     for (const override of config.overrides ?? []) {
         for (const input of resolveJsPlugins(override.jsPlugins, configFilePath))
             inputs.push(input);
+        for (const input of getInputsFromSettings(override.settings))
+            inputs.push(input);
     }
     for (const input of getInputsFromSettings(config.settings))
         inputs.push(input);
     return inputs;
 };
 const resolveConfig = (config, options) => resolveExtendedConfig(config, options.configFilePath);
-const resolveFromAST = (program, options) => {
-    if (!isViteConfig(options.configFileName))
-        return [];
-    const jsPlugins = new Set();
-    const visitor = new Visitor({
-        ObjectExpression(node) {
-            const lint = findProperty(node, 'lint');
-            if (lint?.type !== 'ObjectExpression')
-                return;
-            for (const specifier of getPropertyValues(lint, 'jsPlugins'))
-                jsPlugins.add(specifier);
-            for (const plugin of findProperty(lint, 'jsPlugins')?.elements ?? []) {
-                if (plugin?.type !== 'ObjectExpression')
-                    continue;
-                for (const specifier of getPropertyValues(plugin, 'specifier'))
-                    jsPlugins.add(specifier);
-            }
-        },
-    });
-    visitor.visit(program);
-    return [...resolveJsPlugins([...jsPlugins], options.configFilePath), ...getInputsFromSettingsAST(program)];
-};
 const isFilterTransitiveDependencies = true;
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
-    isLoadConfig,
     resolveConfig,
-    resolveFromAST,
     isFilterTransitiveDependencies,
     args,
 };

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

@@ -4,6 +4,7 @@ type JsPlugin = string | {
     specifier: string;
 };
 type Override = {
+    settings?: Settings;
     jsPlugins?: JsPlugin[];
 };
 export type OxlintConfig = {

package/dist/plugins/playwright/index.js

@@ -1,6 +1,6 @@
 import { arrayify } from '../../util/array.js';
 import { toDeferResolve, toEntry } from '../../util/input.js';
-import { join, relative } from '../../util/path.js';
+import { join, relative, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Playwright';
 const enablers = ['@playwright/test'];
@@ -18,9 +18,26 @@ export const resolveConfig = async (localConfig, options) => {
     const { cwd, configFileDir } = options;
     const inputs = [];
     for (const id of arrayify(localConfig.globalSetup))
-        inputs.push(toEntry(id));
+        inputs.push(toEntry(toAbsolute(id, configFileDir)));
     for (const id of arrayify(localConfig.globalTeardown))
-        inputs.push(toEntry(id));
+        inputs.push(toEntry(toAbsolute(id, configFileDir)));
+    for (const server of [localConfig.webServer].flat()) {
+        if (!server?.command)
+            continue;
+        const dir = server.cwd ? toAbsolute(server.cwd, configFileDir) : configFileDir;
+        for (const input of options.getInputsFromScripts(server.command, {
+            optionalBinaries: true,
+            cwd: dir,
+            manifest: options.getManifest(dir) ?? options.manifest,
+        })) {
+            const inputDir = input.dir ?? dir;
+            inputs.push({
+                ...input,
+                ...(input.type === 'entry' ? { specifier: toAbsolute(input.specifier, inputDir) } : {}),
+                dir: inputDir,
+            });
+        }
+    }
     const projects = localConfig.projects ? [localConfig, ...localConfig.projects] : [localConfig];
     const reporters = [localConfig.reporter].flat().flatMap(reporter => {
         const name = typeof reporter === 'string' ? reporter : reporter?.[0];

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

@@ -31,6 +31,10 @@ type Project = {
     use: string;
     testMatch?: string | RegExp | (string | RegExp)[];
 };
+type TestConfigWebServer = {
+    command: string;
+    cwd?: string;
+};
 export type PlaywrightTestConfig = {
     projects?: Project[];
     testMatch?: string | RegExp | (string | RegExp)[];
@@ -38,5 +42,6 @@ export type PlaywrightTestConfig = {
     reporter?: LiteralUnion<'dot' | 'line' | 'list' | 'junit' | 'html' | 'json' | 'github' | 'null', string> | ReporterDescription[];
     globalSetup?: string | Array<string>;
     globalTeardown?: string | Array<string>;
+    webServer?: TestConfigWebServer | TestConfigWebServer[];
 };
 export {};

package/dist/plugins/postcss/index.js

@@ -11,7 +11,11 @@ const config = [
 ];
 const resolveConfig = config => {
     const plugins = config.plugins
-        ? (Array.isArray(config.plugins) ? config.plugins : Object.keys(config.plugins)).flatMap(plugin => {
+        ? (Array.isArray(config.plugins)
+            ? config.plugins
+            : Object.entries(config.plugins)
+                .filter(([, options]) => options !== false)
+                .map(([plugin]) => plugin)).flatMap(plugin => {
             if (typeof plugin === 'string')
                 return plugin;
             if (Array.isArray(plugin) && typeof plugin[0] === 'string')

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

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

package/dist/plugins/railway/index.js

@@ -0,0 +1,129 @@
+import { Visitor } from 'oxc-parser';
+import { findProperty, getFirstPropertyValue, getStringValues } from '../../typescript/ast-helpers.js';
+import { getStringValue } from '../../typescript/ast-nodes.js';
+import { getGitRemoteUrls } from '../../util/git.js';
+import { isEntry } from '../../util/input.js';
+import { join, toAbsolute } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+const title = 'Railway';
+const enablers = ['railway'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['.railway/railway.ts'];
+const args = {
+    config: ['file'],
+    resolve: ['runner'],
+};
+const getCommands = (node) => {
+    const command = getStringValue(node);
+    return command ? [command] : [...getStringValues(node)];
+};
+const isExternalSourceType = (type) => type === 'github' || type === 'image' || type === 'template';
+const getGitHubRepository = (value) => {
+    const normalized = value
+        ?.trim()
+        .replace(/^git\+/, '')
+        .replace(/\.git\/?$/, '')
+        .replace(/\/$/, '');
+    return normalized?.match(/(?:^|github(?:\.com)?[/:])([^/:]+\/[^/]+)$/i)?.[1].toLowerCase();
+};
+const resolveFromAST = (program, options) => {
+    const serviceNames = new Set();
+    const sourceTypes = new Map();
+    const bindings = new Map();
+    const localRepositories = new Set();
+    for (const repository of [options.manifest.repository, options.rootManifest?.repository]) {
+        const name = getGitHubRepository(typeof repository === 'string' ? repository : repository?.url);
+        if (name)
+            localRepositories.add(name);
+    }
+    for (const url of getGitRemoteUrls(options.rootCwd)) {
+        const name = getGitHubRepository(url);
+        if (name)
+            localRepositories.add(name);
+    }
+    for (const node of program.body) {
+        if (node.type === 'ImportDeclaration' && getStringValue(node.source) === 'railway/iac') {
+            for (const specifier of node.specifiers) {
+                if (specifier.type !== 'ImportSpecifier' || specifier.imported.type !== 'Identifier')
+                    continue;
+                if (specifier.imported.name === 'service')
+                    serviceNames.add(specifier.local.name);
+                if (isExternalSourceType(specifier.imported.name)) {
+                    sourceTypes.set(specifier.local.name, specifier.imported.name);
+                }
+            }
+        }
+        else if (node.type === 'VariableDeclaration') {
+            for (const declaration of node.declarations) {
+                if (declaration.id.type === 'Identifier' && declaration.init)
+                    bindings.set(declaration.id.name, declaration.init);
+            }
+        }
+    }
+    const resolveBinding = (node) => {
+        const seen = new Set();
+        while (node?.type === 'Identifier' && bindings.has(node.name) && !seen.has(node.name)) {
+            seen.add(node.name);
+            node = bindings.get(node.name);
+        }
+        return node;
+    };
+    const inputs = [];
+    const visitor = new Visitor({
+        CallExpression(node) {
+            if (node.callee.type !== 'Identifier' || !serviceNames.has(node.callee.name))
+                return;
+            const serviceConfig = node.arguments[1];
+            if (serviceConfig?.type !== 'ObjectExpression')
+                return;
+            const source = resolveBinding(findProperty(serviceConfig, 'source'));
+            const repository = getFirstPropertyValue(source, 'repo');
+            const image = getFirstPropertyValue(source, 'image');
+            const template = getFirstPropertyValue(source, 'template');
+            const sourceType = (source?.type === 'CallExpression' && source.callee.type === 'Identifier'
+                ? sourceTypes.get(source.callee.name)
+                : undefined) ??
+                getFirstPropertyValue(source, 'type') ??
+                (repository ? 'github' : image ? 'image' : template ? 'template' : undefined);
+            const sourceRepository = getGitHubRepository(source?.type === 'CallExpression' ? getStringValue(source.arguments[0]) : repository);
+            if (sourceType === 'image' ||
+                sourceType === 'template' ||
+                (sourceType === 'github' &&
+                    sourceRepository !== undefined &&
+                    localRepositories.size > 0 &&
+                    !localRepositories.has(sourceRepository))) {
+                return;
+            }
+            const sourceConfig = source?.type === 'CallExpression' ? source.arguments[1] : source;
+            const rootDirectory = getFirstPropertyValue(sourceConfig, 'rootDirectory') ??
+                getFirstPropertyValue(serviceConfig, 'root') ??
+                getFirstPropertyValue(serviceConfig, 'rootDirectory');
+            const cwd = rootDirectory ? join(options.cwd, rootDirectory) : options.cwd;
+            const manifest = options.getManifest(cwd) ?? options.manifest;
+            const build = findProperty(serviceConfig, 'build');
+            const commands = [
+                ...getCommands(build),
+                ...getCommands(findProperty(build, 'buildCommand')),
+                ...getCommands(findProperty(serviceConfig, 'start')),
+                ...getCommands(findProperty(serviceConfig, 'preDeploy')),
+                ...getCommands(findProperty(findProperty(serviceConfig, 'deploy'), 'preDeployCommand')),
+            ];
+            for (const input of options.getInputsFromScripts(commands, { optionalBinaries: true, cwd, manifest })) {
+                if (isEntry(input))
+                    input.specifier = toAbsolute(input.specifier, cwd);
+                inputs.push({ ...input, dir: cwd });
+            }
+        },
+    });
+    visitor.visit(program);
+    return inputs;
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    args,
+    resolveFromAST,
+};
+export default plugin;

package/dist/plugins/rsbuild/index.js

@@ -1,11 +1,13 @@
 import { toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
+import { resolveConfig as resolveRspackConfig } from '../rspack/index.js';
 const title = 'Rsbuild';
 const enablers = ['@rsbuild/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['rsbuild*.config.{mjs,ts,js,cjs,mts,cts}'];
-const resolveConfig = async (config) => {
+const resolveConfig = async (config, options) => {
     const entries = new Set();
+    const inputs = [];
     const checkSource = (source) => {
         if (source?.entry) {
             for (const entry of Object.values(source.entry)) {
@@ -32,13 +34,49 @@ const resolveConfig = async (config) => {
                     entries.add(e);
         }
     };
-    checkSource(config.source);
+    const checkConfig = async (localConfig) => {
+        checkSource(localConfig.source);
+        if (!localConfig.tools?.rspack)
+            return;
+        const target = localConfig.output?.target ?? config.output?.target ?? 'web';
+        const mode = localConfig.mode ?? config.mode;
+        const passes = mode ? [mode === 'production'] : options.isProduction ? [true] : [false, true];
+        for (const rspack of [localConfig.tools.rspack].flat()) {
+            for (const isProduction of typeof rspack === 'function' ? passes : [options.isProduction]) {
+                const baseConfig = {
+                    mode: mode ?? (isProduction ? 'production' : 'development'),
+                    entry: {},
+                    resolve: { alias: {} },
+                    module: { rules: [] },
+                    plugins: [],
+                };
+                const utils = {
+                    env: process.env.NODE_ENV ?? '',
+                    isDev: baseConfig.mode === 'development',
+                    isProd: baseConfig.mode === 'production',
+                    target,
+                    isServer: target === 'node',
+                    isWebWorker: target === 'web-worker',
+                };
+                const resolvedConfig = typeof rspack === 'function' ? await rspack(baseConfig, utils) : rspack;
+                const resolvedInputs = await resolveRspackConfig(resolvedConfig ?? baseConfig, {
+                    ...options,
+                    isProduction: options.isProduction || isProduction,
+                });
+                for (const input of resolvedInputs)
+                    inputs.push(input);
+            }
+        }
+    };
+    await checkConfig(config);
     if (config.environments) {
         for (const environment of Object.values(config.environments)) {
-            checkSource(environment.source);
+            await checkConfig(environment);
         }
     }
-    return Array.from(entries).map(input => toProductionEntry(input));
+    for (const entry of entries)
+        inputs.push(toProductionEntry(entry));
+    return inputs;
 };
 const plugin = {
     title,

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

@@ -1,15 +1,32 @@
+import type { Configuration } from 'webpack';
 type EntryDescription = Record<string, unknown>;
 type Entry = Record<string, string | string[] | (EntryDescription & {
     html?: boolean;
 })>;
+type RspackConfigUtils = {
+    env: string;
+    isDev: boolean;
+    isProd: boolean;
+    target: 'web' | 'node' | 'web-worker';
+    isServer: boolean;
+    isWebWorker: boolean;
+};
+type RspackConfig = Configuration | ((config: Configuration, utils: RspackConfigUtils) => Configuration | void | Promise<Configuration | void>);
 export type RsbuildConfig = {
     plugins?: unknown[];
+    mode?: 'development' | 'production' | 'none';
+    output?: {
+        target?: RspackConfigUtils['target'];
+    };
     source?: {
         entry?: Entry;
         preEntry?: string | string[];
     };
+    tools?: {
+        rspack?: RspackConfig | RspackConfig[];
+    };
     environments?: {
-        [k: string]: Pick<RsbuildConfig, 'plugins' | 'source'>;
+        [k: string]: Omit<RsbuildConfig, 'environments'>;
     };
 };
 export {};

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

@@ -1,3 +1,5 @@
-import type { Plugin } from '../../types/config.ts';
+import type { Plugin, ResolveConfig } from '../../types/config.ts';
+import type { WebpackConfig } from '../webpack/types.ts';
+export declare const resolveConfig: ResolveConfig<WebpackConfig>;
 declare const plugin: Plugin;
 export default plugin;