@rsbuild/core 1.2.7 → 1.2.9

package/dist-types/createRsbuild.d.ts

@@ -1,2 +1,5 @@
 import type { CreateRsbuildOptions, RsbuildInstance } from './types';
+/**
+ * Create an Rsbuild instance.
+ */
 export declare function createRsbuild(options?: CreateRsbuildOptions): Promise<RsbuildInstance>;

package/dist-types/rspack/preload/HtmlPreloadOrPrefetchPlugin.d.ts

@@ -16,15 +16,15 @@
  * limitations under the License.
  */
 import type { Compiler, RspackPluginInstance } from '@rspack/core';
-import type { HtmlRspackPlugin, PreloadOrPreFetchOption } from '../../types';
+import type { HtmlRspackPlugin, PreloadOrPrefetchOption } from '../../types';
 type LinkType = 'preload' | 'prefetch';
 export declare class HtmlPreloadOrPrefetchPlugin implements RspackPluginInstance {
-    readonly options: PreloadOrPreFetchOption;
+    readonly options: PreloadOrPrefetchOption;
     name: string;
     resourceHints: HtmlRspackPlugin.HtmlTagObject[];
     type: LinkType;
     HTMLCount: number;
-    constructor(options: true | PreloadOrPreFetchOption, type: LinkType, HTMLCount: number);
+    constructor(options: true | PreloadOrPrefetchOption, type: LinkType, HTMLCount: number);
     apply(compiler: Compiler): void;
 }
 export {};

package/dist-types/rspack/preload/helpers/doesChunkBelongToHtml.d.ts

@@ -16,13 +16,13 @@
  * limitations under the License.
  */
 import type { Chunk, Compilation } from '@rspack/core';
-import type { PreloadOrPreFetchOption } from '../../../types';
+import type { PreloadOrPrefetchOption } from '../../../types';
 import type { BeforeAssetTagGenerationHtmlPluginData } from './type';
 interface DoesChunkBelongToHtmlOptions {
     chunk: Chunk;
     compilation?: Compilation;
     htmlPluginData: BeforeAssetTagGenerationHtmlPluginData;
-    pluginOptions?: PreloadOrPreFetchOption;
+    pluginOptions?: PreloadOrPrefetchOption;
 }
 export declare function recursiveChunkEntryNames(chunk: Chunk): string[];
 export declare function doesChunkBelongToHtml({ chunk, htmlPluginData, }: DoesChunkBelongToHtmlOptions): boolean;

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

@@ -5,7 +5,17 @@ import type { CreateCompiler, CreateDevServerOptions, EnvironmentAPI, InternalCo
 type HTTPServer = Server | Http2SecureServer;
 export type RsbuildDevServer = {
     /**
-     * Listen the Rsbuild server.
+     * The `connect` app instance.
+     * Can be used to attach custom middlewares to the dev server.
+     */
+    middlewares: Connect.Server;
+    /**
+     * The Node.js HTTP server instance.
+     * Will be `Http2SecureServer` if `server.https` config is used.
+     */
+    httpServer: import('node:http').Server | import('node:http2').Http2SecureServer | null;
+    /**
+     * Start listening on the Rsbuild dev server.
      * Do not call this method if you are using a custom server.
      */
     listen: () => Promise<{
@@ -24,11 +34,6 @@ export type RsbuildDevServer = {
      * By default, Rsbuild server listens on port `3000` and automatically increments the port number if the port is occupied.
      */
     port: number;
-    /**
-     * The `connect` app instance.
-     * Can be used to attach custom middlewares to the dev server.
-     */
-    middlewares: Connect.Server;
     /**
      * Notify that the Rsbuild server has been started.
      * Rsbuild will trigger `onAfterStartDevServer` hook in this stage.

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

@@ -16,10 +16,15 @@ export type RsbuildDevMiddlewareOptions = {
     output: {
         distPath: string;
     };
+    /**
+     * Callbacks returned by the `onBeforeStartDevServer` hook.
+     */
+    postCallbacks: (() => void)[];
 };
 export type Middlewares = Array<RequestHandler | [string, RequestHandler]>;
-export declare const getMiddlewares: (options: RsbuildDevMiddlewareOptions) => Promise<{
+export type GetMiddlewaresResult = {
     close: () => Promise<void>;
     onUpgrade: UpgradeEvent;
     middlewares: Middlewares;
-}>;
+};
+export declare const getMiddlewares: (options: RsbuildDevMiddlewareOptions) => Promise<GetMiddlewaresResult>;

package/dist-types/server/runner/basic.d.ts

@@ -2,6 +2,7 @@ import type { CompilerOptions, Runner } from './type';
 import type { BasicGlobalContext, BasicModuleScope, BasicRunnerFile, ModuleObject, RunnerRequirer } from './type';
 export interface IBasicRunnerOptions {
     name: string;
+    isBundleOutput: (modulePath: string) => boolean;
     runInNewContext?: boolean;
     readFileSync: (path: string) => string;
     dist: string;
@@ -18,6 +19,11 @@ export declare abstract class BasicRunner implements Runner {
     protected abstract createGlobalContext(): BasicGlobalContext;
     protected abstract createBaseModuleScope(): BasicModuleScope;
     protected abstract createModuleScope(requireFn: RunnerRequirer, m: ModuleObject, file: BasicRunnerFile): BasicModuleScope;
+    /**
+     * Get the file information for a given module path.
+     *
+     * @returns An object containing the file path, content, and subPath, or null if the module is not an rspack output.
+     */
     protected getFile(modulePath: string[] | string, currentDirectory: string): BasicRunnerFile | null;
     protected preExecute(_code: string, _file: BasicRunnerFile): void;
     protected postExecute(_m: Record<string, any>, _file: BasicRunnerFile): void;

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

@@ -1,8 +1,10 @@
-import type { CompilerOptions, Runner, RunnerFactory } from './type';
+import type { Runner, RunnerFactory, RunnerFactoryOptions } from './type';
 export declare class BasicRunnerFactory implements RunnerFactory {
     protected name: string;
     constructor(name: string);
-    create(compilerOptions: CompilerOptions, dist: string, readFileSync: (path: string) => string): Runner;
-    protected createRunner(compilerOptions: CompilerOptions, dist: string, readFileSync: (path: string) => string): Runner;
+    create(options: RunnerFactoryOptions): Runner;
+    protected createRunner(options: RunnerFactoryOptions): Runner;
 }
-export declare const run: <T>(bundlePath: string, outputPath: string, compilerOptions: CompilerOptions, readFileSync: (path: string) => string) => Promise<T>;
+export declare const run: <T>({ bundlePath, ...runnerFactoryOptions }: RunnerFactoryOptions & {
+    bundlePath: string;
+}) => Promise<T>;

package/dist-types/server/runner/type.d.ts

@@ -31,6 +31,12 @@ export interface Runner {
     run(file: string): Promise<unknown>;
     getRequire(): RunnerRequirer;
 }
+export type RunnerFactoryOptions = {
+    dist: string;
+    compilerOptions: CompilerOptions;
+    readFileSync: (path: string) => string;
+    isBundleOutput: (modulePath: string) => boolean;
+};
 export interface RunnerFactory {
-    create(compilerOptions: CompilerOptions, dist: string, readFileSync: (fileName: string) => string): Runner;
+    create(options: RunnerFactoryOptions): Runner;
 }

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

@@ -7,8 +7,9 @@ type WatchFilesOptions = {
     compileMiddlewareAPI?: CompileMiddlewareAPI;
     root: string;
 };
-export declare function setupWatchFiles(options: WatchFilesOptions): Promise<{
+export type WatchFilesResult = {
     close(): Promise<void>;
-} | undefined>;
+};
+export declare function setupWatchFiles(options: WatchFilesOptions): Promise<WatchFilesResult | undefined>;
 export declare function createChokidar(pathOrGlobs: string[], root: string, options: ChokidarOptions): Promise<FSWatcher>;
 export {};

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

@@ -336,6 +336,11 @@ export type BuildCacheOptions = {
      * @default undefined
      */
     cacheDigest?: Array<string | undefined>;
+    /**
+     * An array of files containing build dependencies.
+     * Rspack will use the hash of each of these files to invalidate the persistent cache.
+     */
+    buildDependencies?: string[];
 };
 export type PrintFileSizeAsset = {
     /**
@@ -393,11 +398,14 @@ export type Preconnect = Array<string | PreconnectOption>;
 export type DnsPrefetch = string[];
 export type PreloadIncludeType = 'async-chunks' | 'initial' | 'all-assets' | 'all-chunks';
 export type Filter = Array<string | RegExp> | ((filename: string) => boolean);
-export interface PreloadOrPreFetchOption {
+export interface PreloadOrPrefetchOption {
     type?: PreloadIncludeType;
     include?: Filter;
     exclude?: Filter;
+    dedupe?: boolean;
 }
+export type PreloadOption = PreloadOrPrefetchOption;
+export type PrefetchOption = Omit<PreloadOrPrefetchOption, 'dedupe'>;
 export interface PerformanceConfig {
     /**
      * Whether to remove `console.[methodName]` in production build.
@@ -441,14 +449,14 @@ export interface PerformanceConfig {
      *
      * Specifies that the user agent must preemptively fetch and cache the target resource for current navigation.
      */
-    preload?: true | PreloadOrPreFetchOption;
+    preload?: true | PreloadOption;
     /**
      * Used to control resource `Prefetch`.
      *
      * Specifies that the user agent should preemptively fetch and cache the target resource as it
      * is likely to be required for a followup navigation.
      */
-    prefetch?: true | PreloadOrPreFetchOption;
+    prefetch?: true | PrefetchOption;
     /**
      * Whether capture timing information for each module,
      * same as the [profile](https://webpack.js.org/configuration/other-options/#profile) config of webpack.

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

@@ -1,5 +1,6 @@
 import type { ChainIdentifier } from '..';
 import type RspackChain from '../../compiled/rspack-chain/index.js';
+import type { RsbuildDevServer } from '../server/devServer';
 import type { EnvironmentConfig, HtmlBasicTag, MergedEnvironmentConfig, NormalizedEnvironmentConfig, RsbuildConfig } from './config';
 import type { RsbuildEntry, RsbuildTarget } from './rsbuild';
 import type { Rspack } from './rspack';
@@ -33,8 +34,15 @@ export type OnDevCompileDoneFn = (params: {
     environments: Record<string, EnvironmentContext>;
 }) => MaybePromise<void>;
 export type OnBeforeStartDevServerFn = (params: {
+    /**
+     * The dev server instance, the same as the return value of `createDevServer`.
+     */
+    server: RsbuildDevServer;
+    /**
+     * A read-only object that provides some context information about different environments.
+     */
     environments: Record<string, EnvironmentContext>;
-}) => MaybePromise<void>;
+}) => MaybePromise<(() => void) | void>;
 export type OnBeforeStartProdServerFn = () => MaybePromise<void>;
 export type Routes = Array<{
     entryName: string;

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

@@ -4,7 +4,7 @@ import type { ChainIdentifier } from '../configChain';
 import type { ModifyRspackConfigUtils, NormalizedConfig, NormalizedEnvironmentConfig, RsbuildConfig } from './config';
 import type { RsbuildContext } from './context';
 import type { EnvironmentContext, ModifyBundlerChainFn, ModifyChainUtils, ModifyEnvironmentConfigFn, ModifyHTMLTagsFn, ModifyRsbuildConfigFn, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterEnvironmentCompileFn, OnAfterStartDevServerFn, OnAfterStartProdServerFn, OnBeforeBuildFn, OnBeforeCreateCompilerFn, OnBeforeEnvironmentCompileFn, OnBeforeStartDevServerFn, OnBeforeStartProdServerFn, OnCloseBuildFn, OnCloseDevServerFn, OnDevCompileDoneFn, OnExitFn } from './hooks';
-import type { RsbuildTarget } from './rsbuild';
+import type { RsbuildInstance, RsbuildTarget } from './rsbuild';
 import type { Rspack } from './rspack';
 import type { HtmlRspackPlugin } from './thirdParty';
 import type { Falsy } from './utils';
@@ -14,27 +14,82 @@ export type HookDescriptor<T extends (...args: any[]) => any> = {
     handler: T;
     order: HookOrder;
 };
-export type EnvironmentAsyncHook<Callback extends (...args: any[]) => any> = {
+export type EnvironmentAsyncHook<Callback extends (...args: any[]) => T, T = any> = {
+    /**
+     * Registers a callback function to be executed when the hook is triggered.
+     * The callback can be a plain function or a HookDescriptor that includes execution order.
+     * The callback will be executed in all environments by default.
+     * If you need to specify the environment, please use `tapEnvironment`
+     * @param cb The callback function or hook descriptor to register
+     */
+    tap: (cb: Callback | HookDescriptor<Callback>) => void;
+    /**
+     * Registers a callback function to be executed when the hook is triggered.
+     * The callback will only be executed under the specified environment.
+     */
     tapEnvironment: (params: {
         /**
-         * Specify that the callback will only be executed under the specified environment
+         * Specify the environment that the callback will be executed under.
          */
         environment?: string;
+        /**
+         * The callback function or hook descriptor to register
+         */
         handler: Callback | HookDescriptor<Callback>;
     }) => void;
     /**
-     *  Triggered in all environments by default.
-     *  If you need to specify the environment, please use `tapEnvironment`
+     * Executes callbacks in sequence independently and collects all their results into an array.
+     * Each callback receives the original parameters, and their results don't affect subsequent callbacks.
+     * @returns A promise that resolves with an array containing the results of all callbacks
      */
-    tap: (cb: Callback | HookDescriptor<Callback>) => void;
-    callInEnvironment: (params: {
+    callChain: (params: {
+        /**
+         * Specify the environment for filtering callbacks.
+         */
         environment?: string;
+        /**
+         * The parameters to pass to each callback
+         */
         args: Parameters<Callback>;
     }) => Promise<Parameters<Callback>>;
+    /**
+     * Executes callbacks in sequence independently and collects all their results into an array.
+     * Each callback receives the original parameters, and their results don't affect subsequent callbacks.
+     * @returns A promise that resolves with an array containing the results of all callbacks
+     */
+    callBatch: (params: {
+        /**
+         * Specify the environment for filtering callbacks.
+         */
+        environment?: string;
+        /**
+         * The parameters to pass to each callback
+         */
+        args: Parameters<Callback>;
+    }) => Promise<Awaited<ReturnType<Callback>>[]>;
 };
-export type AsyncHook<Callback extends (...args: any[]) => any> = {
+export type AsyncHook<Callback extends (...args: any[]) => T, T = any> = {
+    /**
+     * Registers a callback function to be executed when the hook is triggered.
+     * The callback can be a plain function or a HookDescriptor that includes execution order.
+     * @param cb The callback function or hook descriptor to register
+     */
     tap: (cb: Callback | HookDescriptor<Callback>) => void;
-    call: (...args: Parameters<Callback>) => Promise<Parameters<Callback>>;
+    /**
+     * Executes callbacks in sequence, passing the result of each callback as the first argument
+     * to the next callback in the chain. If a callback returns undefined, the original arguments
+     * will be passed to the next callback.
+     * @param params The initial parameters to pass to the first callback
+     * @returns A promise that resolves with the final parameters after all callbacks have executed
+     */
+    callChain: (...args: Parameters<Callback>) => Promise<Parameters<Callback>>;
+    /**
+     * Executes callbacks in sequence independently and collects all their results into an array.
+     * Each callback receives the original parameters, and their results don't affect subsequent callbacks.
+     * @param params The parameters to pass to each callback
+     * @returns A promise that resolves with an array containing the results of all callbacks
+     */
+    callBatch: (...args: Parameters<Callback>) => Promise<Awaited<ReturnType<Callback>>[]>;
 };
 export type ModifyRspackConfigFn = (config: Rspack.Configuration, utils: ModifyRspackConfigUtils) => MaybePromise<Rspack.Configuration | void>;
 export type ModifyWebpackChainUtils = ModifyChainUtils & {
@@ -63,42 +118,7 @@ export type PluginMeta = {
     environment: string;
     instance: RsbuildPlugin;
 };
-export type PluginManager = {
-    getPlugins: (options?: {
-        /**
-         * Get the plugins in the specified environment.
-         *
-         * If environment is not specified, get the global plugins.
-         */
-        environment: string;
-    }) => RsbuildPlugin[];
-    addPlugins: (plugins: Array<RsbuildPlugin | Falsy>, options?: {
-        /**
-         * Insert before the specified plugin.
-         */
-        before?: string;
-        /**
-         * Add a plugin for the specified environment.
-         * If environment is not specified, it will be registered as a global plugin (effective in all environments)
-         */
-        environment?: string;
-    }) => void;
-    removePlugins: (pluginNames: string[], options?: {
-        /**
-         * Remove the plugin in the specified environment.
-         *
-         * If environment is not specified, remove it in all environments.
-         */
-        environment: string;
-    }) => void;
-    isPluginExists: (pluginName: string, options?: {
-        /**
-         * Whether it exists in the specified environment.
-         *
-         * If environment is not specified, determine whether the plugin is a global plugin.
-         */
-        environment: string;
-    }) => boolean;
+export type PluginManager = Pick<RsbuildInstance, 'getPlugins' | 'addPlugins' | 'isPluginExists' | 'removePlugins'> & {
     /** Get all plugins with environment info */
     getAllPluginsWithMeta: () => PluginMeta[];
 };
@@ -300,50 +320,157 @@ declare function getNormalizedConfig(options: {
  * Define a generic Rsbuild plugin API that provider can extend as needed.
  */
 export type RsbuildPluginAPI = Readonly<{
+    /**
+     * A read-only object that provides some context information.
+     */
     context: Readonly<RsbuildContext>;
-    isPluginExists: PluginManager['isPluginExists'];
-    onExit: PluginHook<OnExitFn>;
-    onCloseBuild: PluginHook<OnCloseBuildFn>;
+    /**
+     * Explicitly expose some properties or methods of the current plugin,
+     * and other plugins can get these APIs through `api.useExposed`.
+     */
+    expose: <T = any>(id: string | symbol, api: T) => void;
+    /**
+     * Get the Rsbuild config, this method must be called after the
+     * `modifyRsbuildConfig` hook is executed.
+     */
+    getRsbuildConfig: GetRsbuildConfig;
+    /**
+     * Get the all normalized Rsbuild config or the Rsbuild config of a specified
+     * environment, this method must be called after the
+     * `modifyRsbuildConfig` hook is executed.
+     */
+    getNormalizedConfig: typeof getNormalizedConfig;
+    /**
+     * Determines if a plugin has been registered in the current Rsbuild instance.
+     */
+    isPluginExists: (pluginName: string, options?: {
+        /**
+         * Whether it exists in the specified environment.
+         * If environment is not specified, determine whether the plugin is a global plugin.
+         */
+        environment: string;
+    }) => boolean;
+    /**
+     * Allows you to modify the Rspack configuration using the `rspack-chain` API,
+     * providing the same functionality as `tools.bundlerChain`.
+     */
+    modifyBundlerChain: PluginHook<ModifyBundlerChainFn>;
+    /**
+     * Modify the Rsbuild configuration of a specific environment.
+     */
+    modifyEnvironmentConfig: PluginHook<ModifyEnvironmentConfigFn>;
+    /**
+     * Modify the tags that are injected into the HTML.
+     */
+    modifyHTMLTags: PluginHook<ModifyHTMLTagsFn>;
+    /**
+     * To modify the Rspack config, you can directly modify the config object,
+     * or return a new object to replace the previous object.
+     */
+    modifyRspackConfig: PluginHook<ModifyRspackConfigFn>;
+    /**
+     * Modify the config passed to the Rsbuild, you can directly modify the config object,
+     * or return a new object to replace the previous object.
+     */
+    modifyRsbuildConfig: PluginHook<ModifyRsbuildConfigFn>;
+    /**
+     * Allows you to modify the webpack configuration using the `rspack-chain` API,
+     * providing the same functionality as `tools.bundlerChain`.
+     */
+    modifyWebpackChain: PluginHook<ModifyWebpackChainFn>;
+    /**
+     * To modify the webpack config, you can directly modify the config object,
+     * or return a new object to replace the previous object.
+     */
+    modifyWebpackConfig: PluginHook<ModifyWebpackConfigFn>;
+    /**
+     * A callback function that is triggered after running the production build.
+     * You can access the build result information via the
+     * [stats](https://rspack.dev/api/javascript-api/stats) parameter.
+     */
     onAfterBuild: PluginHook<OnAfterBuildFn>;
-    onBeforeBuild: PluginHook<OnBeforeBuildFn>;
+    /**
+     * A callback function that is triggered after the compiler instance has been
+     * created, but before the build process. This hook is called when you run
+     * `rsbuild.startDevServer`, `rsbuild.build`, or `rsbuild.createCompiler`.
+     */
+    onAfterCreateCompiler: PluginHook<OnAfterCreateCompilerFn>;
+    /**
+     * A callback function that is triggered after the compilation of a single environment.
+     * You can access the build result information via the
+     * [stats](https://rspack.dev/api/javascript-api/stats) parameter.
+     */
     onAfterEnvironmentCompile: PluginHook<OnAfterEnvironmentCompileFn>;
-    onBeforeEnvironmentCompile: PluginHook<OnBeforeEnvironmentCompileFn>;
-    onCloseDevServer: PluginHook<OnCloseDevServerFn>;
-    onDevCompileDone: PluginHook<OnDevCompileDoneFn>;
+    /**
+     * Called after starting the dev server, you can get the port number with the
+     * `port` parameter, and the page routes info with the `routes` parameter.
+     */
     onAfterStartDevServer: PluginHook<OnAfterStartDevServerFn>;
-    onBeforeStartDevServer: PluginHook<OnBeforeStartDevServerFn>;
+    /**
+     * Called after starting the production preview server, you can get the port
+     * number with the `port` parameter, and the page routes info with the
+     * `routes` parameter.
+     */
     onAfterStartProdServer: PluginHook<OnAfterStartProdServerFn>;
-    onBeforeStartProdServer: PluginHook<OnBeforeStartProdServerFn>;
-    onAfterCreateCompiler: PluginHook<OnAfterCreateCompilerFn>;
+    /**
+     * A callback function that is triggered before the production build is executed.
+     */
+    onBeforeBuild: PluginHook<OnBeforeBuildFn>;
+    /**
+     * A callback function that is triggered after the Compiler instance has been
+     * created, but before the build process begins. This hook is called when you
+     * run `rsbuild.startDevServer`, `rsbuild.build`, or `rsbuild.createCompiler`.
+     */
     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
+     * A callback function that is triggered before the compilation of a single environment.
      */
-    expose: <T = any>(id: string | symbol, api: T) => void;
-    useExposed: <T = any>(id: string | symbol) => T | undefined;
+    onBeforeEnvironmentCompile: PluginHook<OnBeforeEnvironmentCompileFn>;
     /**
-     * Used to transform the code of modules.
+     * Called before starting the dev server.
      */
-    transform: TransformFn;
+    onBeforeStartDevServer: PluginHook<OnBeforeStartDevServerFn>;
     /**
-     * Process all the asset generated by Rspack.
+     * Called before starting the production preview server.
+     */
+    onBeforeStartProdServer: PluginHook<OnBeforeStartProdServerFn>;
+    /**
+     * Called when closing the build instance. Can be used to perform cleanup
+     * operations when the building is closed.
+     */
+    onCloseBuild: PluginHook<OnCloseBuildFn>;
+    /**
+     * Called when closing the dev server. Can be used to perform cleanup
+     * operations when the dev server is closed.
+     */
+    onCloseDevServer: PluginHook<OnCloseDevServerFn>;
+    /**
+     * Called after each development mode build, you can use `isFirstCompile`
+     * to determine whether it is the first build.
+     */
+    onDevCompileDone: PluginHook<OnDevCompileDoneFn>;
+    /**
+     * Called when the process is going to exit, this hook can only execute
+     * synchronous code.
+     */
+    onExit: PluginHook<OnExitFn>;
+    /**
+     * Modify assets before emitting, the same as Rspack's
+     * [compilation.hooks.processAssets](https://rspack.dev/api/plugin-api/compilation-hooks#processassets) hook.
      */
     processAssets: ProcessAssetsFn;
     /**
-     * Defines a custom resolver. A resolver can be useful for e.g. locating third-party dependencies.
+     * Intercept and modify module request information before module resolution begins.
+     * The same as Rspack's [normalModuleFactory.hooks.resolve](https://rspack.dev/api/plugin-api/normal-module-factory-hooks#resolve) hook.
      */
     resolve: ResolveFn;
+    /**
+     * Used to transform the code of modules.
+     */
+    transform: TransformFn;
+    /**
+     * Get the properties or methods exposed by other plugins.
+     */
+    useExposed: <T = any>(id: string | symbol) => T | undefined;
 }>;
 export {};