@rsbuild/core 1.0.0-alpha.2 → 1.0.0-alpha.3

package/dist-types/types/config/server.d.ts

@@ -0,0 +1,106 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { SecureServerSessionOptions } from 'node:http2';
+import type { ServerOptions as HttpsServerOptions } from 'node:https';
+import type { Options as BaseProxyOptions, Filter as ProxyFilter } from '../../../compiled/http-proxy-middleware';
+import type { Routes } from '../hooks';
+export type HtmlFallback = false | 'index';
+export type ProxyDetail = BaseProxyOptions & {
+    bypass?: (req: IncomingMessage, res: ServerResponse, proxyOptions: ProxyOptions) => string | undefined | null | boolean;
+    context?: ProxyFilter;
+};
+export type ProxyOptions = Record<string, string> | Record<string, ProxyDetail> | ProxyDetail[] | ProxyDetail;
+export type HistoryApiFallbackContext = {
+    match: RegExpMatchArray;
+    parsedUrl: import('node:url').Url;
+    request: Request;
+};
+export type HistoryApiFallbackOptions = {
+    index?: string;
+    verbose?: boolean;
+    logger?: typeof console.log;
+    htmlAcceptHeaders?: string[];
+    disableDotRule?: true;
+    rewrites?: Array<{
+        from: RegExp;
+        to: string | RegExp | ((context: HistoryApiFallbackContext) => string);
+    }>;
+};
+export type PrintUrls = boolean | ((params: {
+    urls: string[];
+    port: number;
+    routes: Routes;
+    protocol: string;
+}) => string[] | void);
+export type PublicDirOptions = {
+    /**
+     * The name of the public directory, can be set as a relative path or an absolute path.
+     * @default 'public'
+     */
+    name?: string;
+    /**
+     * Whether to copy files from the publicDir to the distDir on production build
+     * @default true
+     */
+    copyOnBuild?: boolean;
+    /**
+     * whether to watch the public directory and reload the page when the files change
+     * @default false
+     */
+    watch?: boolean;
+};
+export type PublicDir = false | PublicDirOptions | PublicDirOptions[];
+export interface ServerConfig {
+    /**
+     * Whether to enable gzip compression
+     */
+    compress?: boolean;
+    /**
+     * Serving static files from the directory (by default 'public' directory)
+     */
+    publicDir?: PublicDir;
+    /**
+     * Specify a port number for Rsbuild Server to listen.
+     */
+    port?: number;
+    /**
+     * After configuring this option, you can enable HTTPS Server, and disabling the HTTP Server.
+     */
+    https?: HttpsServerOptions | SecureServerSessionOptions;
+    /**
+     * Used to set the host of Rsbuild Server.
+     */
+    host?: string;
+    /**
+     * Adds headers to all responses.
+     */
+    headers?: Record<string, string | string[]>;
+    /**
+     * Whether to support html fallback.
+     */
+    htmlFallback?: HtmlFallback;
+    /**
+     * Provide alternative pages for some 404 responses or other requests.
+     * see https://github.com/bripkens/connect-history-api-fallback
+     */
+    historyApiFallback?: boolean | HistoryApiFallbackOptions;
+    /**
+     * Set the page URL to open when the server starts.
+     */
+    open?: boolean | string | string[] | {
+        target?: string | string[];
+        before?: () => Promise<void> | void;
+    };
+    /**
+     * Configure proxy rules for the dev server or preview server to proxy requests to the specified service.
+     */
+    proxy?: ProxyOptions;
+    /**
+     * Whether to throw an error when the port is occupied.
+     */
+    strictPort?: boolean;
+    /**
+     * Whether to print the server urls when the server is started.
+     */
+    printUrls?: PrintUrls;
+}
+export type NormalizedServerConfig = ServerConfig & Required<Pick<ServerConfig, 'htmlFallback' | 'port' | 'host' | 'compress' | 'strictPort' | 'printUrls' | 'open'>>;

package/dist-types/types/config/source.d.ts

@@ -0,0 +1,79 @@
+import type { RuleSetCondition } from '@rspack/core';
+import type { RsbuildEntry } from '../rsbuild';
+import type { ConfigChain } from '../utils';
+export type Alias = Record<string, string | false | (string | false)[]>;
+export type Define = Record<string, any>;
+export type AliasStrategy = 'prefer-tsconfig' | 'prefer-alias';
+export type Decorators = {
+    /**
+     * Specify the version of decorators to use.
+     * @default 'legacy''
+     */
+    version?: 'legacy' | '2022-03';
+};
+export interface SourceConfig {
+    /**
+     * Create aliases to import or require certain modules,
+     * same as the [resolve.alias](https://rspack.dev/config/resolve) config of Rspack.
+     */
+    alias?: ConfigChain<Alias>;
+    /**
+     * Used to control the priority between the `paths` option in `tsconfig.json`
+     * and the `alias` option in the bundler.
+     */
+    aliasStrategy?: AliasStrategy;
+    /**
+     * Specify directories or modules that need additional compilation.
+     * In order to maintain faster compilation speed, Rsbuild will not compile files under node_modules through
+     * `babel-loader` or `ts-loader` by default, as will as the files outside the current project directory.
+     */
+    include?: RuleSetCondition[];
+    /**
+     * Set the entry modules.
+     */
+    entry?: RsbuildEntry;
+    /**
+     * Specifies that certain files that will be excluded from compilation.
+     */
+    exclude?: RuleSetCondition[];
+    /**
+     * Add a script before the entry file of each page.
+     * This script will be executed before the page code.
+     * It can be used to execute global logics, such as polyfill injection.
+     */
+    preEntry?: string | string[];
+    /**
+     * Used to replaces variables in your code with other values or expressions at compile time.
+     */
+    define?: Define;
+    /**
+     * Configuring decorators syntax.
+     */
+    decorators?: Decorators;
+    /**
+     * Used to import the code and style of the component library on demand.
+     */
+    transformImport?: false | TransformImport[];
+    /**
+     * Configure a custom tsconfig.json file path to use, can be a relative or absolute path.
+     * @default 'tsconfig.json'
+     */
+    tsconfigPath?: string;
+}
+export type TransformImport = {
+    libraryName: string;
+    libraryDirectory?: string;
+    style?: string | boolean;
+    styleLibraryDirectory?: string;
+    camelToDashComponentName?: boolean;
+    transformToDefaultImport?: boolean;
+    customName?: any;
+    customStyleName?: any;
+};
+export interface NormalizedSourceConfig extends SourceConfig {
+    define: Define;
+    alias: ConfigChain<Alias>;
+    aliasStrategy: AliasStrategy;
+    preEntry: string[];
+    decorators: Required<Decorators>;
+}

package/dist-types/types/config/tools.d.ts

@@ -0,0 +1,86 @@
+import type { rspack } from '@rspack/core';
+import type { SwcLoaderOptions } from '@rspack/core';
+import type { Options as HTMLPluginOptions } from 'html-webpack-plugin';
+import type RspackChain from '../../../compiled/rspack-chain';
+import type { ModifyBundlerChainUtils, ModifyChainUtils } from '../hooks';
+import type { ModifyWebpackChainUtils, ModifyWebpackConfigUtils } from '../plugin';
+import type { BundlerPluginInstance, Rspack, RspackConfig, RspackRule } from '../rspack';
+import type { AutoprefixerOptions, CSSExtractOptions, CSSLoaderOptions, PostCSSLoaderOptions, PostCSSPlugin, StyleLoaderOptions, WebpackConfig } from '../thirdParty';
+import type { ConfigChain, ConfigChainAsyncWithContext, ConfigChainWithContext } from '../utils';
+import type { MaybePromise, OneOrMany } from '../utils';
+export type { HTMLPluginOptions };
+export type ToolsSwcConfig = ConfigChain<SwcLoaderOptions>;
+export type ToolsAutoprefixerConfig = ConfigChain<AutoprefixerOptions>;
+export type ToolsBundlerChainConfig = OneOrMany<(chain: RspackChain, utils: ModifyBundlerChainUtils) => MaybePromise<void>>;
+export type ToolsPostCSSLoaderConfig = ConfigChainWithContext<PostCSSLoaderOptions, {
+    addPlugins: (plugins: PostCSSPlugin | PostCSSPlugin[]) => void;
+}>;
+export type ToolsCSSLoaderConfig = ConfigChain<CSSLoaderOptions>;
+export type ToolsStyleLoaderConfig = ConfigChain<StyleLoaderOptions>;
+export type ToolsHtmlPluginConfig = ConfigChainWithContext<HTMLPluginOptions, {
+    entryName: string;
+    entryValue: (string | string[] | Rspack.EntryDescription)[];
+}>;
+export type ModifyRspackConfigUtils = ModifyChainUtils & {
+    addRules: (rules: RspackRule | RspackRule[]) => void;
+    prependPlugins: (plugins: BundlerPluginInstance | BundlerPluginInstance[]) => void;
+    appendPlugins: (plugins: BundlerPluginInstance | BundlerPluginInstance[]) => void;
+    removePlugin: (pluginName: string) => void;
+    mergeConfig: typeof import('../../../compiled/webpack-merge').merge;
+    rspack: typeof rspack;
+};
+export type ToolsRspackConfig = ConfigChainAsyncWithContext<RspackConfig, ModifyRspackConfigUtils>;
+export type ToolsWebpackConfig = ConfigChainWithContext<WebpackConfig, ModifyWebpackConfigUtils>;
+export type ToolsWebpackChainConfig = OneOrMany<(chain: RspackChain, utils: ModifyWebpackChainUtils) => void>;
+export interface ToolsConfig {
+    /**
+     * Configure bundler config base on [rspack-chain](https://github.com/rspack-contrib/rspack-chain)
+     */
+    bundlerChain?: ToolsBundlerChainConfig;
+    /**
+     * Modify the config of [autoprefixer](https://github.com/postcss/autoprefixer)
+     */
+    autoprefixer?: ToolsAutoprefixerConfig;
+    /**
+     * Modify the options of [css-loader](https://github.com/webpack-contrib/css-loader).
+     */
+    cssLoader?: ToolsCSSLoaderConfig;
+    /**
+     * Modify the options of [postcss-loader](https://github.com/webpack-contrib/postcss-loader).
+     */
+    postcss?: ToolsPostCSSLoaderConfig;
+    /**
+     * Modify the options of [style-loader](https://github.com/webpack-contrib/style-loader).
+     */
+    styleLoader?: ToolsStyleLoaderConfig;
+    /**
+     * Configure the html-webpack-plugin.
+     */
+    htmlPlugin?: boolean | ToolsHtmlPluginConfig;
+    /**
+     * Configure the `builtin:swc-loader` of Rspack.
+     */
+    swc?: ToolsSwcConfig;
+    /**
+     * Modify the options of [CssExtractRspackPlugin](https://rspack.dev/plugins/rspack/css-extract-rspack-plugin).
+     */
+    cssExtract?: CSSExtractOptions;
+    /**
+     * Configure Rspack.
+     * @requires rspack
+     */
+    rspack?: ToolsRspackConfig;
+    /**
+     * Configure [webpack](https://webpack.js.org/).
+     * @requires webpack
+     */
+    webpack?: ToolsWebpackConfig;
+    /**
+     * Configure webpack by [rspack-chain](https://github.com/rspack-contrib/rspack-chain).
+     * @requires webpack
+     */
+    webpackChain?: ToolsWebpackChainConfig;
+}
+export type NormalizedToolsConfig = ToolsConfig & {
+    cssExtract: Required<CSSExtractOptions>;
+};

package/dist-types/types/context.d.ts

@@ -0,0 +1,38 @@
+import type { Hooks } from '../initHooks';
+import type { NormalizedConfig, RsbuildConfig } from './config';
+import type { EnvironmentContext } from './hooks';
+import type { RsbuildPluginAPI } from './plugin';
+export type BundlerType = 'rspack' | 'webpack';
+/** The public context */
+export type RsbuildContext = {
+    /** The Rsbuild core version. */
+    version: string;
+    /** The root path of current project. */
+    rootPath: string;
+    /** Absolute path of output files. */
+    distPath: string;
+    /** Absolute path of cache files. */
+    cachePath: string;
+    /** Info of dev server  */
+    devServer?: {
+        hostname: string;
+        port: number;
+        https: boolean;
+    };
+    bundlerType: BundlerType;
+};
+/** The inner context. */
+export type InternalContext = RsbuildContext & {
+    /** All hooks. */
+    hooks: Readonly<Hooks>;
+    /** Current Rsbuild config. */
+    config: Readonly<RsbuildConfig>;
+    /** The original Rsbuild config passed from the createRsbuild method. */
+    originalConfig: Readonly<RsbuildConfig>;
+    /** The normalized Rsbuild config. */
+    normalizedConfig?: NormalizedConfig;
+    /** The plugin API. */
+    pluginAPI?: RsbuildPluginAPI;
+    /** The environment context. */
+    environments: Record<string, EnvironmentContext>;
+};

package/dist-types/types/hooks.d.ts

@@ -0,0 +1,125 @@
+import type HtmlWebpackPlugin from 'html-webpack-plugin';
+import type RspackChain from '../../compiled/rspack-chain';
+import type { ChainIdentifier } from '..';
+import type { EnvironmentConfig, HtmlBasicTag, MergedEnvironmentConfig, NormalizedEnvironmentConfig, RsbuildConfig } from './config';
+import type { RsbuildEntry, RsbuildTarget } from './rsbuild';
+import type { Rspack } from './rspack';
+import type { MultiStats, Stats } from './stats';
+import type { WebpackConfig } from './thirdParty';
+import type { MaybePromise, NodeEnv } from './utils';
+export type OnBeforeBuildFn<B = 'rspack'> = (params: {
+    bundlerConfigs?: B extends 'rspack' ? Rspack.Configuration[] : WebpackConfig[];
+    environments: Record<string, EnvironmentContext>;
+}) => MaybePromise<void>;
+export type OnAfterBuildFn = (params: {
+    isFirstCompile: boolean;
+    stats?: Stats | MultiStats;
+    environments: Record<string, EnvironmentContext>;
+}) => MaybePromise<void>;
+export type OnCloseDevServerFn = () => MaybePromise<void>;
+export type OnDevCompileDoneFn = (params: {
+    isFirstCompile: boolean;
+    stats: Stats | MultiStats;
+    environments: Record<string, EnvironmentContext>;
+}) => MaybePromise<void>;
+export type OnBeforeStartDevServerFn = (params: {
+    environments: Record<string, EnvironmentContext>;
+}) => MaybePromise<void>;
+export type OnBeforeStartProdServerFn = () => MaybePromise<void>;
+export type Routes = Array<{
+    entryName: string;
+    pathname: string;
+}>;
+export type OnAfterStartDevServerFn = (params: {
+    port: number;
+    routes: Routes;
+    environments: Record<string, EnvironmentContext>;
+}) => MaybePromise<void>;
+export type OnAfterStartProdServerFn = (params: {
+    port: number;
+    routes: Routes;
+}) => MaybePromise<void>;
+export type OnBeforeCreateCompilerFn<B = 'rspack'> = (params: {
+    bundlerConfigs: B extends 'rspack' ? Rspack.Configuration[] : WebpackConfig[];
+    environments: Record<string, EnvironmentContext>;
+}) => MaybePromise<void>;
+export type OnAfterCreateCompilerFn<Compiler = Rspack.Compiler | Rspack.MultiCompiler> = (params: {
+    compiler: Compiler;
+    environments: Record<string, EnvironmentContext>;
+}) => MaybePromise<void>;
+export type OnExitFn = () => void;
+type HTMLTags = {
+    headTags: HtmlBasicTag[];
+    bodyTags: HtmlBasicTag[];
+};
+export type ModifyHTMLTagsContext = {
+    /**
+     * The Compilation object of Rspack.
+     */
+    compilation: Rspack.Compilation;
+    /**
+     * URL prefix of assets.
+     * @example 'https://example.com/'
+     */
+    assetPrefix: string;
+    /**
+     * The name of the HTML file, relative to the dist directory.
+     * @example 'index.html'
+     */
+    filename: string;
+    /** The related environment context. */
+    environment: EnvironmentContext;
+};
+export type ModifyHTMLTagsFn = (tags: HTMLTags, context: ModifyHTMLTagsContext) => MaybePromise<HTMLTags>;
+export type ModifyRsbuildConfigUtils = {
+    /** Merge multiple Rsbuild config objects into one. */
+    mergeRsbuildConfig: (...configs: RsbuildConfig[]) => RsbuildConfig;
+};
+export type ModifyEnvironmentConfigUtils = {
+    /** environment name. */
+    name: string;
+    /** Merge multiple Rsbuild environment config objects into one. */
+    mergeEnvironmentConfig: (config: MergedEnvironmentConfig, ...configs: EnvironmentConfig[]) => MergedEnvironmentConfig;
+};
+export type ModifyRsbuildConfigFn = (config: RsbuildConfig, utils: ModifyRsbuildConfigUtils) => MaybePromise<RsbuildConfig | void>;
+export type ModifyEnvironmentConfigFn = (config: MergedEnvironmentConfig, utils: ModifyEnvironmentConfigUtils) => MaybePromise<MergedEnvironmentConfig | void>;
+export type EnvironmentContext = {
+    index: number;
+    name: string;
+    entry: RsbuildEntry;
+    htmlPaths: Record<string, string>;
+    distPath: string;
+    browserslist: string[];
+    tsconfigPath?: string;
+    config: NormalizedEnvironmentConfig;
+};
+export type ModifyChainUtils = {
+    env: NodeEnv;
+    isDev: boolean;
+    isProd: boolean;
+    target: RsbuildTarget;
+    isServer: boolean;
+    isWebWorker: boolean;
+    CHAIN_ID: ChainIdentifier;
+    environment: EnvironmentContext;
+    HtmlPlugin: typeof HtmlWebpackPlugin;
+};
+interface PluginInstance {
+    apply: (compiler: any) => void;
+    [k: string]: any;
+}
+export type ModifyBundlerChainUtils = ModifyChainUtils & {
+    bundler: {
+        BannerPlugin: PluginInstance;
+        DefinePlugin: PluginInstance;
+        IgnorePlugin: PluginInstance;
+        ProvidePlugin: PluginInstance;
+        HotModuleReplacementPlugin: PluginInstance;
+    };
+};
+export type ModifyBundlerChainFn = (chain: RspackChain, utils: ModifyBundlerChainUtils) => MaybePromise<void>;
+export type CreateAsyncHook<Callback extends (...args: any[]) => any> = {
+    tap: (cb: Callback) => void;
+    call: (...args: Parameters<Callback>) => Promise<Parameters<Callback>>;
+};
+export {};

package/dist-types/types/index.d.ts

@@ -0,0 +1,9 @@
+export * from './rspack';
+export * from './rsbuild';
+export * from './context';
+export * from './utils';
+export * from './plugin';
+export * from './config';
+export * from './stats';
+export * from './hooks';
+export * from './thirdParty';

package/dist-types/types/plugin.d.ts

@@ -0,0 +1,194 @@
+import type { RuleSetCondition } from '@rspack/core';
+import type HtmlWebpackPlugin from 'html-webpack-plugin';
+import type RspackChain from '../../compiled/rspack-chain';
+import type { RuleSetRule, Configuration as WebpackConfig, WebpackPluginInstance } from 'webpack';
+import type { ChainIdentifier } from '../configChain';
+import type { ModifyRspackConfigUtils, NormalizedConfig, NormalizedEnvironmentConfig, RsbuildConfig } from './config';
+import type { RsbuildContext } from './context';
+import type { ModifyBundlerChainFn, ModifyChainUtils, ModifyEnvironmentConfigFn, ModifyHTMLTagsFn, ModifyRsbuildConfigFn, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterStartDevServerFn, OnAfterStartProdServerFn, OnBeforeBuildFn, OnBeforeCreateCompilerFn, OnBeforeStartDevServerFn, OnBeforeStartProdServerFn, OnCloseDevServerFn, OnDevCompileDoneFn, OnExitFn } from './hooks';
+import type { RsbuildTarget } from './rsbuild';
+import type { RspackConfig, RspackSourceMap } from './rspack';
+import type { Falsy } from './utils';
+import type { MaybePromise } from './utils';
+type HookOrder = 'pre' | 'post' | 'default';
+export type HookDescriptor<T extends (...args: any[]) => any> = {
+    handler: T;
+    order: HookOrder;
+};
+export type AsyncHook<Callback extends (...args: any[]) => any> = {
+    tap: (cb: Callback | HookDescriptor<Callback>) => void;
+    call: (...args: Parameters<Callback>) => Promise<Parameters<Callback>>;
+};
+export type ModifyRspackConfigFn = (config: RspackConfig, utils: ModifyRspackConfigUtils) => Promise<RspackConfig | void> | RspackConfig | void;
+export type ModifyWebpackChainUtils = ModifyChainUtils & {
+    webpack: typeof import('webpack');
+    CHAIN_ID: ChainIdentifier;
+    /**
+     * @deprecated Use target instead.
+     * */
+    name: string;
+    /**
+     * @deprecated Use HtmlPlugin instead.
+     */
+    HtmlWebpackPlugin: typeof HtmlWebpackPlugin;
+};
+export type ModifyWebpackConfigUtils = ModifyWebpackChainUtils & {
+    addRules: (rules: RuleSetRule | RuleSetRule[]) => void;
+    prependPlugins: (plugins: WebpackPluginInstance | WebpackPluginInstance[]) => void;
+    appendPlugins: (plugins: WebpackPluginInstance | WebpackPluginInstance[]) => void;
+    removePlugin: (pluginName: string) => void;
+    mergeConfig: typeof import('..').merge;
+};
+export type ModifyWebpackChainFn = (chain: RspackChain, utils: ModifyWebpackChainUtils) => Promise<void> | void;
+export type ModifyWebpackConfigFn = (config: WebpackConfig, utils: ModifyWebpackConfigUtils) => Promise<WebpackConfig | void> | WebpackConfig | void;
+export type PluginManager = {
+    getPlugins: () => RsbuildPlugin[];
+    addPlugins: (plugins: Array<RsbuildPlugin | Falsy>, options?: {
+        before?: string;
+    }) => void;
+    removePlugins: (pluginNames: string[]) => void;
+    isPluginExists: (pluginName: string) => boolean;
+    /** The plugin API. */
+    pluginAPI?: RsbuildPluginAPI;
+};
+/**
+ * The type of the Rsbuild plugin object.
+ */
+export type RsbuildPlugin = {
+    /**
+     * The name of the plugin, a unique identifier.
+     */
+    name: string;
+    /**
+     * The setup function of the plugin, which can be an async function.
+     * This function is called once when the plugin is initialized.
+     * @param api provides the context info, utility functions and lifecycle hooks.
+     */
+    setup: (api: RsbuildPluginAPI) => MaybePromise<void>;
+    /**
+     * Declare the names of pre-plugins, which will be executed before the current plugin.
+     */
+    pre?: string[];
+    /**
+     * Declare the names of post-plugins, which will be executed after the current plugin.
+     */
+    post?: string[];
+    /**
+     * Declare the plugins that need to be removed, you can pass an array of plugin names.
+     */
+    remove?: string[];
+};
+export type RsbuildPlugins = (RsbuildPlugin | Falsy | Promise<RsbuildPlugin | Falsy>)[];
+export type GetRsbuildConfig = {
+    (): Readonly<RsbuildConfig>;
+    (type: 'original' | 'current'): Readonly<RsbuildConfig>;
+    (type: 'normalized'): NormalizedConfig;
+};
+type PluginHook<T extends (...args: any[]) => any> = (options: T | HookDescriptor<T>) => void;
+type TransformResult = string | {
+    code: string;
+    map?: string | RspackSourceMap | null;
+};
+export type TransformContext = {
+    /**
+     * The code of the module.
+     */
+    code: string;
+    /**
+     * The absolute path of the module, including the query.
+     * @example '/home/user/project/src/index.js?foo=123'
+     */
+    resource: string;
+    /**
+     * The absolute path of the module, without the query.
+     * @example '/home/user/project/src/index.js'
+     */
+    resourcePath: string;
+    /**
+     * The query of the module.
+     * @example '?foo=123'
+     */
+    resourceQuery: string;
+    /**
+     * Add an additional file as the dependency.
+     * The file will be watched and changes to the file will trigger rebuild.
+     * @param file The absolute path of the module
+     */
+    addDependency: (file: string) => void;
+    /**
+     * Emits a file to the build output.
+     * @param name file name of the asset
+     * @param content the source of the asset
+     * @param sourceMap source map of the asset
+     * @param assetInfo additional asset information
+     */
+    emitFile: (name: string, content: string | Buffer, sourceMap?: string, assetInfo?: Record<string, any>) => void;
+};
+export type TransformHandler = (context: TransformContext) => MaybePromise<TransformResult>;
+export type TransformDescriptor = {
+    /**
+     * Include modules that match the test assertion, the same as `rule.test`
+     * @see https://rspack.dev/config/module#ruletest
+     */
+    test?: RuleSetCondition;
+    /**
+     * A condition that matches the resource query.
+     * @see https://rspack.dev/config/module#ruleresourcequery
+     */
+    resourceQuery?: RuleSetCondition;
+    /**
+     * Match based on the Rsbuild targets and only apply the transform to certain targets.
+     * @see https://rsbuild.dev/config/output/targets
+     */
+    targets?: RsbuildTarget[];
+    /**
+     * If raw is `true`, the transform handler will receive the Buffer type code instead of the string type.
+     * @see https://rspack.dev/api/loader-api#raw-loader
+     */
+    raw?: boolean;
+};
+export type TransformFn = (descriptor: TransformDescriptor, handler: TransformHandler) => void;
+declare function getNormalizedConfig(): NormalizedConfig;
+declare function getNormalizedConfig(options: {
+    environment: string;
+}): NormalizedEnvironmentConfig;
+/**
+ * Define a generic Rsbuild plugin API that provider can extend as needed.
+ */
+export type RsbuildPluginAPI = Readonly<{
+    context: Readonly<RsbuildContext>;
+    isPluginExists: PluginManager['isPluginExists'];
+    onExit: PluginHook<OnExitFn>;
+    onAfterBuild: PluginHook<OnAfterBuildFn>;
+    onBeforeBuild: PluginHook<OnBeforeBuildFn>;
+    onCloseDevServer: PluginHook<OnCloseDevServerFn>;
+    onDevCompileDone: PluginHook<OnDevCompileDoneFn>;
+    onAfterStartDevServer: PluginHook<OnAfterStartDevServerFn>;
+    onBeforeStartDevServer: PluginHook<OnBeforeStartDevServerFn>;
+    onAfterStartProdServer: PluginHook<OnAfterStartProdServerFn>;
+    onBeforeStartProdServer: PluginHook<OnBeforeStartProdServerFn>;
+    onAfterCreateCompiler: PluginHook<OnAfterCreateCompilerFn>;
+    onBeforeCreateCompiler: PluginHook<OnBeforeCreateCompilerFn>;
+    modifyHTMLTags: PluginHook<ModifyHTMLTagsFn>;
+    modifyRsbuildConfig: PluginHook<ModifyRsbuildConfigFn>;
+    modifyEnvironmentConfig: PluginHook<ModifyEnvironmentConfigFn>;
+    modifyBundlerChain: PluginHook<ModifyBundlerChainFn>;
+    /** Only works when bundler is Rspack */
+    modifyRspackConfig: PluginHook<ModifyRspackConfigFn>;
+    /** Only works when bundler is Webpack */
+    modifyWebpackChain: PluginHook<ModifyWebpackChainFn>;
+    /** Only works when bundler is Webpack */
+    modifyWebpackConfig: PluginHook<ModifyWebpackConfigFn>;
+    getRsbuildConfig: GetRsbuildConfig;
+    getNormalizedConfig: typeof getNormalizedConfig;
+    /**
+     * For plugin communication
+     */
+    expose: <T = any>(id: string | symbol, api: T) => void;
+    useExposed: <T = any>(id: string | symbol) => T | undefined;
+    /**
+     * Used to transform the code of modules.
+     */
+    transform: TransformFn;
+}>;
+export {};